Upload 87 files

app.py

@@ -354,6 +354,32 @@ _BENCH_TEST_PROMPTS = [
 ]
 
 
+def _figs_to_gallery(figs: list) -> list[tuple[str, str]]:
+    """Convert matplotlib Figures to gallery-compatible (filepath, caption) tuples."""
+    import tempfile
+    import os
+    gallery = []
+    for i, fig in enumerate(figs):
+        try:
+            path = os.path.join(tempfile.gettempdir(), f"obliteratus_chart_{i}_{int(time.time())}.png")
+            fig.savefig(path, dpi=150, bbox_inches="tight", facecolor="white", edgecolor="none")
+            # Extract caption from figure suptitle or axes title
+            caption = f"Chart {i + 1}"
+            suptitle = fig._suptitle
+            if suptitle is not None:
+                caption = suptitle.get_text()
+            elif fig.axes:
+                ax_title = fig.axes[0].get_title()
+                if ax_title:
+                    caption = ax_title
+            import matplotlib.pyplot as plt
+            plt.close(fig)
+            gallery.append((path, caption))
+        except Exception:
+            pass
+    return gallery if gallery else None
+
+
 def benchmark(
     model_choice: str,
     methods_to_test: list[str],
@@ -366,7 +392,7 @@ def benchmark(
     This is the API endpoint that enables programmatic benchmarking — call it
     via the Gradio Client API to test what works on your T4 GPU.
 
-    Yields streaming progress updates as (status_md, results_md, log_text).
+    Yields streaming progress updates as (status_md, results_md, log_text, gallery).
     """
     import json as _json
 
@@ -404,7 +430,7 @@ def benchmark(
     all_logs.append(f"Prompt volume: {vol_label} (using {actual_n} pairs)")
     all_logs.append("=" * 60)
 
-    yield "**Starting benchmark...**", "", "\n".join(all_logs)
+    yield "**Starting benchmark...**", "", "\n".join(all_logs), None
 
     for mi, method_key in enumerate(methods_to_test):
         # Clean up between runs
@@ -427,6 +453,7 @@ def benchmark(
             f"**Benchmarking {method_key}** ({mi + 1}/{len(methods_to_test)})...",
             _format_benchmark_results(results, bench_context),
             "\n".join(all_logs),
+            None,
         )
 
         def on_log(msg):
@@ -478,6 +505,7 @@ def benchmark(
                     f"**Benchmarking {method_key}** ({mi + 1}/{len(methods_to_test)})...",
                     _format_benchmark_results(results, bench_context),
                     "\n".join(all_logs),
+                    None,
                 )
             time.sleep(0.5)
 
@@ -500,6 +528,9 @@ def benchmark(
             entry["strong_layers"] = 0
             entry["ega_expert_dirs"] = 0
             entry["ega_safety_layers"] = 0
+            entry["cot_preserved"] = 0
+            entry["kl_optimized"] = False
+            entry["lora_adapters"] = 0
             all_logs.append(f"  ERROR: {run_error}")
         else:
             pipeline = pipeline_ref[0]
@@ -512,6 +543,9 @@ def benchmark(
                 len(d) for d in pipeline._expert_directions.values()
             )
             entry["ega_safety_layers"] = len(pipeline._expert_safety_scores)
+            entry["cot_preserved"] = len(getattr(pipeline, "_cot_preserve_directions", {}))
+            entry["kl_optimized"] = bool(getattr(pipeline, "_kl_contributions", {}))
+            entry["lora_adapters"] = len(getattr(pipeline, "_lora_adapters", {}))
 
             all_logs.append(f"  Completed in {elapsed:.1f}s")
             all_logs.append(f"  Perplexity: {entry['perplexity']}")
@@ -532,13 +566,22 @@ def benchmark(
             f"**{method_key} complete** ({mi + 1}/{len(methods_to_test)})",
             _format_benchmark_results(results, bench_context),
             "\n".join(all_logs),
+            None,
         )
 
     _clear_gpu()
 
+    # Generate dashboard visualizations
+    from obliteratus.evaluation.benchmark_plots import generate_benchmark_dashboard
+    dashboard_figs = generate_benchmark_dashboard(results, mode="multi_method", title_suffix=f" — {model_id}")
+
+    # Convert figures to gallery images
+    gallery_images = _figs_to_gallery(dashboard_figs)
+
     # Final summary
     all_logs.append("\n" + "=" * 60)
     all_logs.append("BENCHMARK COMPLETE")
+    all_logs.append(f"Generated {len(dashboard_figs)} visualizations")
     all_logs.append("=" * 60)
     all_logs.append("\nJSON results:")
     all_logs.append(_json.dumps(results, indent=2, default=str))
@@ -546,9 +589,10 @@ def benchmark(
     progress(1.0, desc="Benchmark complete")
 
     yield (
-        f"**Benchmark complete** — {len(results)} methods tested on {model_id}",
+        f"**Benchmark complete** — {len(results)} methods tested on {model_id} — {len(dashboard_figs)} charts generated",
         _format_benchmark_results(results, bench_context),
         "\n".join(all_logs),
+        gallery_images,
     )
 
 
@@ -569,8 +613,8 @@ def _format_benchmark_results(results: list[dict], context: dict | None = None)
         lines.append("")
 
     lines.extend([
-        "| Method | Time | Perplexity | Coherence | Refusal Rate | Layers | EGA Dirs | Error |",
-        "|--------|------|-----------|-----------|-------------|--------|----------|-------|",
+        "| Method | Time | Perplexity | Coherence | Refusal Rate | Layers | EGA | CoT | KL-Opt | Error |",
+        "|--------|------|-----------|-----------|-------------|--------|-----|-----|--------|-------|",
     ])
 
     best_ppl = None
@@ -588,6 +632,8 @@ def _format_benchmark_results(results: list[dict], context: dict | None = None)
         coh = f"{r['coherence']:.0%}" if r.get("coherence") is not None else "—"
         ref = f"{r['refusal_rate']:.0%}" if r.get("refusal_rate") is not None else "—"
         ega = str(r.get("ega_expert_dirs", 0))
+        cot = str(r.get("cot_preserved", "—"))
+        kl_opt = "Yes" if r.get("kl_optimized") else "—"
         err = r.get("error", "")
         err_short = (err[:30] + "...") if err and len(err) > 30 else (err or "")
 
@@ -599,7 +645,7 @@ def _format_benchmark_results(results: list[dict], context: dict | None = None)
 
         lines.append(
             f"| **{r['method']}** | {r['time_s']}s | {ppl} | {coh} | {ref} "
-            f"| {r.get('strong_layers', '—')} | {ega} | {err_short} |"
+            f"| {r.get('strong_layers', '—')} | {ega} | {cot} | {kl_opt} | {err_short} |"
         )
 
     if len(results) > 1:
@@ -609,6 +655,272 @@ def _format_benchmark_results(results: list[dict], context: dict | None = None)
     return "\n".join(lines)
 
 
+# ---------------------------------------------------------------------------
+# Multi-model benchmark (new: 1 technique across N models)
+# ---------------------------------------------------------------------------
+
+def benchmark_multi_model(
+    model_choices: list[str],
+    method_choice: str,
+    prompt_volume_choice: str,
+    dataset_source_choice: str = "",
+    progress=gr.Progress(),
+):
+    """Run one abliteration method across multiple models and compare.
+
+    This is the complement to the existing `benchmark()` function which runs
+    multiple methods on one model.  Together they provide full coverage:
+    - benchmark():             N methods x 1 model  (which technique is best?)
+    - benchmark_multi_model(): 1 method  x N models (how does technique X scale?)
+
+    Yields streaming progress updates as (status_md, results_md, log_text).
+    """
+    import json as _json
+    import shutil
+
+    method_key = method_choice
+    prompt_volume = PROMPT_VOLUMES.get(prompt_volume_choice, 33)
+    dataset_key = get_source_key_from_label(dataset_source_choice) if dataset_source_choice else "builtin"
+
+    if not model_choices:
+        yield "**Error:** Select at least one model.", "", "", None
+        return
+
+    # Pre-load dataset once
+    harmful_all, harmless_all = load_dataset_source(dataset_key)
+    source_info = DATASET_SOURCES.get(dataset_key)
+    source_label = source_info.label if source_info else dataset_key
+
+    if prompt_volume > 0:
+        actual_n = min(prompt_volume, len(harmful_all), len(harmless_all))
+    else:
+        actual_n = min(len(harmful_all), len(harmless_all))
+
+    results = []
+    all_logs = []
+    bench_context = {
+        "method": method_key,
+        "dataset": source_label,
+        "volume": actual_n,
+    }
+
+    all_logs.append(f"MULTI-MODEL BENCHMARK")
+    all_logs.append(f"Method: {method_key}")
+    all_logs.append(f"Models: {len(model_choices)}")
+    all_logs.append(f"Dataset: {source_label} ({actual_n} pairs)")
+    all_logs.append("=" * 60)
+
+    yield "**Starting multi-model benchmark...**", "", "\n".join(all_logs), None
+
+    for mi, model_display in enumerate(model_choices):
+        model_id = MODELS.get(model_display, model_display)
+
+        _clear_gpu()
+        gc.collect()
+
+        run_logs = []
+        run_error = None
+        pipeline_ref = [None]
+        t_start = time.time()
+
+        progress(mi / len(model_choices), desc=f"Running {model_id}...")
+
+        all_logs.append(f"\n{'─' * 60}")
+        all_logs.append(f"MODEL: {model_id} ({mi + 1}/{len(model_choices)})")
+        all_logs.append(f"{'─' * 60}")
+
+        yield (
+            f"**Testing {model_id}** ({mi + 1}/{len(model_choices)})...",
+            _format_multi_model_results(results, bench_context),
+            "\n".join(all_logs),
+            None,
+        )
+
+        def on_log(msg, _mk=method_key, _mid=model_id):
+            run_logs.append(msg)
+            all_logs.append(f"  [{_mid.split('/')[-1]}] {msg}")
+
+        def on_stage(result):
+            pass
+
+        quantization = _should_quantize(model_id)
+
+        def run_pipeline():
+            try:
+                from obliteratus.abliterate import AbliterationPipeline
+
+                n = actual_n
+                pipeline = AbliterationPipeline(
+                    model_name=model_id,
+                    output_dir=f"/tmp/bench_mm_{mi}",
+                    device="auto",
+                    dtype="float16",
+                    method=method_key,
+                    quantization=quantization,
+                    harmful_prompts=harmful_all[:n],
+                    harmless_prompts=harmless_all[:n],
+                    on_stage=on_stage,
+                    on_log=on_log,
+                )
+                pipeline_ref[0] = pipeline
+                pipeline.run()
+            except Exception as e:
+                nonlocal run_error
+                run_error = e
+
+        worker = threading.Thread(target=run_pipeline, daemon=True)
+        worker.start()
+
+        last_count = len(all_logs)
+        while worker.is_alive():
+            if len(all_logs) > last_count:
+                last_count = len(all_logs)
+                yield (
+                    f"**Testing {model_id}** ({mi + 1}/{len(model_choices)})...",
+                    _format_multi_model_results(results, bench_context),
+                    "\n".join(all_logs),
+                    None,
+                )
+            time.sleep(0.5)
+
+        worker.join()
+        elapsed = time.time() - t_start
+
+        entry = {
+            "model": model_id,
+            "model_short": model_id.split("/")[-1],
+            "method": method_key,
+            "time_s": round(elapsed, 1),
+            "error": None,
+        }
+
+        if run_error is not None:
+            entry["error"] = str(run_error)
+            entry["perplexity"] = None
+            entry["coherence"] = None
+            entry["refusal_rate"] = None
+            entry["strong_layers"] = 0
+            entry["ega_expert_dirs"] = 0
+            entry["ega_safety_layers"] = 0
+            entry["cot_preserved"] = 0
+            entry["kl_optimized"] = False
+            entry["lora_adapters"] = 0
+            all_logs.append(f"  ERROR: {run_error}")
+        else:
+            pipeline = pipeline_ref[0]
+            metrics = pipeline._quality_metrics
+            entry["perplexity"] = metrics.get("perplexity")
+            entry["coherence"] = metrics.get("coherence")
+            entry["refusal_rate"] = metrics.get("refusal_rate")
+            entry["strong_layers"] = len(pipeline._strong_layers)
+            entry["ega_expert_dirs"] = sum(
+                len(d) for d in pipeline._expert_directions.values()
+            )
+            entry["ega_safety_layers"] = len(pipeline._expert_safety_scores)
+            # Frontier feature metrics
+            entry["cot_preserved"] = len(getattr(pipeline, "_cot_preserve_directions", {}))
+            entry["kl_optimized"] = bool(getattr(pipeline, "_kl_contributions", {}))
+            entry["lora_adapters"] = len(getattr(pipeline, "_lora_adapters", {}))
+
+            all_logs.append(f"  Completed in {elapsed:.1f}s")
+            all_logs.append(f"  PPL={entry['perplexity']}, Coherence={entry['coherence']}, Refusal={entry['refusal_rate']}")
+
+        results.append(entry)
+
+        # Cleanup
+        save_path = Path(f"/tmp/bench_mm_{mi}")
+        if save_path.exists():
+            import shutil
+            shutil.rmtree(save_path, ignore_errors=True)
+
+        yield (
+            f"**{model_id} complete** ({mi + 1}/{len(model_choices)})",
+            _format_multi_model_results(results, bench_context),
+            "\n".join(all_logs),
+            None,
+        )
+
+    _clear_gpu()
+
+    # Generate dashboard visualizations
+    from obliteratus.evaluation.benchmark_plots import generate_benchmark_dashboard
+    dashboard_figs = generate_benchmark_dashboard(results, mode="multi_model", title_suffix=f" — {method_key}")
+    gallery_images = _figs_to_gallery(dashboard_figs)
+
+    all_logs.append("\n" + "=" * 60)
+    all_logs.append("MULTI-MODEL BENCHMARK COMPLETE")
+    all_logs.append(f"Generated {len(dashboard_figs)} visualizations")
+    all_logs.append("=" * 60)
+    all_logs.append("\nJSON results:")
+    all_logs.append(_json.dumps(results, indent=2, default=str))
+
+    progress(1.0, desc="Benchmark complete")
+
+    yield (
+        f"**Benchmark complete** — {method_key} tested on {len(results)} models — {len(dashboard_figs)} charts generated",
+        _format_multi_model_results(results, bench_context),
+        "\n".join(all_logs),
+        gallery_images,
+    )
+
+
+def _format_multi_model_results(results: list[dict], context: dict | None = None) -> str:
+    """Format multi-model benchmark results as a Markdown table."""
+    if not results:
+        return "*No results yet...*"
+
+    lines = []
+
+    if context:
+        lines.append(
+            f"**Method:** `{context.get('method', '?')}` | "
+            f"**Dataset:** {context.get('dataset', '?')} | "
+            f"**Volume:** {context.get('volume', '?')} prompts"
+        )
+        lines.append("")
+
+    lines.extend([
+        "| Model | Time | Perplexity | Coherence | Refusal Rate | Layers | EGA | CoT | Error |",
+        "|-------|------|-----------|-----------|-------------|--------|-----|-----|-------|",
+    ])
+
+    best_ppl = None
+    best_ref = None
+    for r in results:
+        if r.get("perplexity") is not None:
+            if best_ppl is None or r["perplexity"] < best_ppl:
+                best_ppl = r["perplexity"]
+        if r.get("refusal_rate") is not None:
+            if best_ref is None or r["refusal_rate"] < best_ref:
+                best_ref = r["refusal_rate"]
+
+    for r in results:
+        model = r.get("model_short", r.get("model", "?"))
+        ppl = f"{r['perplexity']:.2f}" if r.get("perplexity") is not None else "—"
+        coh = f"{r['coherence']:.0%}" if r.get("coherence") is not None else "—"
+        ref = f"{r['refusal_rate']:.0%}" if r.get("refusal_rate") is not None else "—"
+        ega = str(r.get("ega_expert_dirs", 0))
+        cot = str(r.get("cot_preserved", "—"))
+        err = r.get("error", "")
+        err_short = (err[:25] + "...") if err and len(err) > 25 else (err or "")
+
+        if r.get("perplexity") is not None and r["perplexity"] == best_ppl and len(results) > 1:
+            ppl = f"**{ppl}**"
+        if r.get("refusal_rate") is not None and r["refusal_rate"] == best_ref and len(results) > 1:
+            ref = f"**{ref}**"
+
+        lines.append(
+            f"| {model} | {r['time_s']}s | {ppl} | {coh} | {ref} "
+            f"| {r.get('strong_layers', '—')} | {ega} | {cot} | {err_short} |"
+        )
+
+    if len(results) > 1:
+        lines.append("")
+        lines.append("*Bold = best in column. Lower perplexity & refusal = better.*")
+
+    return "\n".join(lines)
+
+
 def obliterate(model_choice: str, method_choice: str, hub_repo: str,
                prompt_volume_choice: str, dataset_source_choice: str,
                custom_harmful: str, custom_harmless: str,
@@ -1020,6 +1332,448 @@ def get_chat_header():
     return "No model loaded. Use the **Obliterate** tab to liberate a model first."
 
 
+# ---------------------------------------------------------------------------
+# A/B Comparison Chat
+# ---------------------------------------------------------------------------
+
+def ab_chat_respond(message: str, history_left: list[dict], history_right: list[dict],
+                    system_prompt: str, temperature: float, top_p: float,
+                    max_tokens: int, repetition_penalty: float):
+    """Generate responses from BOTH original and abliterated model side-by-side.
+
+    Left panel = original (pre-abliteration), Right panel = abliterated.
+    The original model is loaded temporarily for comparison then freed.
+    """
+    with _lock:
+        abliterated_model = _state["model"]
+        tokenizer = _state["tokenizer"]
+        model_name = _state["model_name"]
+
+    if abliterated_model is None or tokenizer is None:
+        yield (history_left + [{"role": "user", "content": message},
+                                {"role": "assistant", "content": "No abliterated model loaded. Obliterate a model first."}],
+               history_right + [{"role": "user", "content": message},
+                                 {"role": "assistant", "content": "No abliterated model loaded. Obliterate a model first."}],
+               "Load a model first.")
+        return
+
+    # Build messages
+    messages = []
+    if system_prompt.strip():
+        messages.append({"role": "system", "content": system_prompt})
+    # Use right-panel history (abliterated) as the conversation context
+    for msg in history_right:
+        messages.append({"role": msg["role"], "content": msg["content"]})
+    messages.append({"role": "user", "content": message})
+
+    try:
+        text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    except Exception:
+        text = "\n".join(f"{m['role']}: {m['content']}" for m in messages) + "\nassistant:"
+
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=2048)
+
+    gen_kwargs_base = {
+        "max_new_tokens": int(max_tokens),
+        "do_sample": temperature > 0,
+        "temperature": max(temperature, 0.01),
+        "top_p": top_p,
+        "repetition_penalty": float(repetition_penalty),
+        "no_repeat_ngram_size": 4,
+    }
+
+    # Add user message to both histories
+    new_left = history_left + [{"role": "user", "content": message}]
+    new_right = history_right + [{"role": "user", "content": message}]
+
+    # --- Generate from abliterated model (streaming) ---
+    streamer_abl = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+    inputs_abl = {k: v.to(abliterated_model.device) for k, v in inputs.items()}
+    gen_kwargs_abl = {**inputs_abl, **gen_kwargs_base, "streamer": streamer_abl}
+
+    gen_error_abl = [None]
+
+    def _gen_abliterated(**kwargs):
+        try:
+            abliterated_model.generate(**kwargs)
+        except Exception as e:
+            gen_error_abl[0] = e
+            streamer_abl.end()
+
+    thread_abl = threading.Thread(target=_gen_abliterated, kwargs=gen_kwargs_abl)
+    thread_abl.start()
+
+    partial_abl = ""
+    for token in streamer_abl:
+        partial_abl += token
+        yield (new_left + [{"role": "assistant", "content": "*Generating after abliterated response...*"}],
+               new_right + [{"role": "assistant", "content": partial_abl}],
+               "Streaming abliterated response...")
+
+    thread_abl.join()
+    if gen_error_abl[0]:
+        partial_abl += f"\n\n**[Error]** {gen_error_abl[0]}"
+
+    # --- Generate from original model ---
+    yield (new_left + [{"role": "assistant", "content": "*Loading original model for comparison...*"}],
+           new_right + [{"role": "assistant", "content": partial_abl}],
+           "Loading original model...")
+
+    # Load original model (smaller footprint: use same dtype)
+    model_id = MODELS.get(model_name, model_name)
+    original_response = ""
+    try:
+        from transformers import AutoModelForCausalLM as AMCLM
+        original_model = AMCLM.from_pretrained(
+            model_id, torch_dtype=torch.float16,
+            device_map="auto", trust_remote_code=True,
+            low_cpu_mem_usage=True,
+        )
+
+        streamer_orig = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+        inputs_orig = {k: v.to(original_model.device) for k, v in inputs.items()}
+        gen_kwargs_orig = {**inputs_orig, **gen_kwargs_base, "streamer": streamer_orig}
+
+        gen_error_orig = [None]
+
+        def _gen_original(**kwargs):
+            try:
+                original_model.generate(**kwargs)
+            except Exception as e:
+                gen_error_orig[0] = e
+                streamer_orig.end()
+
+        thread_orig = threading.Thread(target=_gen_original, kwargs=gen_kwargs_orig)
+        thread_orig.start()
+
+        for token in streamer_orig:
+            original_response += token
+            yield (new_left + [{"role": "assistant", "content": original_response}],
+                   new_right + [{"role": "assistant", "content": partial_abl}],
+                   "Streaming original response...")
+
+        thread_orig.join()
+        if gen_error_orig[0]:
+            original_response += f"\n\n**[Error]** {gen_error_orig[0]}"
+
+        # Free the original model
+        del original_model
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    except Exception as e:
+        original_response = f"*Could not load original model for comparison: {e}*"
+
+    yield (new_left + [{"role": "assistant", "content": original_response}],
+           new_right + [{"role": "assistant", "content": partial_abl}],
+           "Done — compare the responses above.")
+
+
+# ---------------------------------------------------------------------------
+# Ablation Strength Sweep (dose-response curve)
+# ---------------------------------------------------------------------------
+
+def strength_sweep(model_choice: str, method_choice: str,
+                   prompt_vol_choice: str, dataset_source_choice: str,
+                   sweep_steps: int, progress=gr.Progress()):
+    """Sweep regularization from 0.0→1.0 and measure refusal rate + perplexity.
+
+    Produces a dose-response curve: the fundamental plot for abliteration research.
+    """
+    from obliteratus.abliterate import AbliterationPipeline
+
+    model_id = MODELS.get(model_choice, model_choice)
+    method_key = METHODS.get(method_choice, "advanced")
+    dataset_key = get_source_key_from_label(dataset_source_choice) if dataset_source_choice else "builtin"
+
+    sweep_steps = max(3, min(int(sweep_steps), 20))
+    regs = [round(i / (sweep_steps - 1), 3) for i in range(sweep_steps)]
+
+    results = []
+    all_logs = [f"Ablation Strength Sweep: {model_choice} x {method_key}",
+                f"Sweep points: {regs}", ""]
+
+    yield "Starting sweep...", "", "\n".join(all_logs), None, None
+
+    # Pre-load dataset
+    harmful_all, harmless_all = load_dataset_source(dataset_key)
+    prompt_volume = PROMPT_VOLUMES.get(prompt_vol_choice, 33)
+    harmful = harmful_all[:prompt_volume] if prompt_volume < len(harmful_all) else harmful_all
+    harmless = harmless_all[:prompt_volume] if prompt_volume < len(harmless_all) else harmless_all
+
+    for step_i, reg in enumerate(regs):
+        progress((step_i) / len(regs), desc=f"reg={reg:.2f}")
+        all_logs.append(f"--- Regularization = {reg:.3f} ---")
+        yield (f"Sweep {step_i+1}/{len(regs)}: reg={reg:.3f}",
+               _format_sweep_results(results),
+               "\n".join(all_logs), None, None)
+
+        t0 = time.time()
+        pipeline_ref = [None]
+        run_error = None
+
+        def _run_sweep_point():
+            try:
+                pipe = AbliterationPipeline(
+                    model_id, method=method_key,
+                    harmful_prompts=harmful, harmless_prompts=harmless,
+                    regularization=reg,
+                    on_log=lambda msg: all_logs.append(f"  [{reg:.2f}] {msg}"),
+                )
+                pipe.run()
+                pipeline_ref[0] = pipe
+            except Exception as e:
+                nonlocal run_error
+                run_error = e
+
+        worker = threading.Thread(target=_run_sweep_point)
+        worker.start()
+        while worker.is_alive():
+            worker.join(timeout=2.0)
+            yield (f"Sweep {step_i+1}/{len(regs)}: reg={reg:.3f} ...",
+                   _format_sweep_results(results),
+                   "\n".join(all_logs), None, None)
+        worker.join()
+
+        elapsed = round(time.time() - t0, 1)
+        entry = {"regularization": reg, "time_s": elapsed}
+
+        if run_error is not None:
+            entry["error"] = str(run_error)
+            entry["perplexity"] = None
+            entry["refusal_rate"] = None
+            entry["coherence"] = None
+        else:
+            pipe = pipeline_ref[0]
+            metrics = pipe._quality_metrics
+            entry["perplexity"] = metrics.get("perplexity")
+            entry["refusal_rate"] = metrics.get("refusal_rate")
+            entry["coherence"] = metrics.get("coherence")
+            entry["strong_layers"] = len(pipe._strong_layers)
+            del pipe
+
+        results.append(entry)
+        all_logs.append(f"  Done in {elapsed}s — PPL={entry.get('perplexity', '?')}, "
+                        f"Refusal={entry.get('refusal_rate', '?')}")
+
+        # Cleanup between runs
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    # Generate dose-response curve
+    gallery = None
+    try:
+        import matplotlib
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+        import tempfile, os
+
+        valid = [r for r in results if r.get("perplexity") is not None]
+        if valid:
+            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
+            fig.suptitle(f"Ablation Strength Sweep: {model_choice} ({method_key})",
+                         fontsize=13, fontweight="bold", color="#222")
+
+            x = [r["regularization"] for r in valid]
+            ppl = [r["perplexity"] for r in valid]
+            ref = [r["refusal_rate"] for r in valid]
+            coh = [r.get("coherence") for r in valid]
+
+            # Left: refusal rate vs regularization
+            color_ref = "#d62728"
+            color_ppl = "#1f77b4"
+            ax1.plot(x, ref, "o-", color=color_ref, linewidth=2, markersize=8, label="Refusal Rate")
+            ax1.set_xlabel("Regularization (0=full removal, 1=no change)", fontsize=10)
+            ax1.set_ylabel("Refusal Rate", color=color_ref, fontsize=10)
+            ax1.tick_params(axis="y", labelcolor=color_ref)
+            ax1.set_ylim(-0.05, 1.05)
+            ax1.set_xlim(-0.05, 1.05)
+            ax1.grid(True, alpha=0.3)
+            ax1.set_title("Dose-Response Curve", fontsize=11, fontweight="bold")
+
+            ax1b = ax1.twinx()
+            ax1b.plot(x, ppl, "s--", color=color_ppl, linewidth=2, markersize=7, label="Perplexity")
+            ax1b.set_ylabel("Perplexity", color=color_ppl, fontsize=10)
+            ax1b.tick_params(axis="y", labelcolor=color_ppl)
+
+            # Combined legend
+            lines1, labels1 = ax1.get_legend_handles_labels()
+            lines2, labels2 = ax1b.get_legend_handles_labels()
+            ax1.legend(lines1 + lines2, labels1 + labels2, loc="center right")
+
+            # Right: Pareto plot (refusal vs perplexity)
+            ax2.scatter(ref, ppl, c=x, cmap="RdYlGn", s=120, edgecolors="black", linewidth=1, zorder=3)
+            for r in valid:
+                ax2.annotate(f"{r['regularization']:.2f}",
+                             (r["refusal_rate"], r["perplexity"]),
+                             textcoords="offset points", xytext=(8, 5),
+                             fontsize=8, alpha=0.8)
+            ax2.set_xlabel("Refusal Rate (lower = better removal)", fontsize=10)
+            ax2.set_ylabel("Perplexity (lower = better coherence)", fontsize=10)
+            ax2.set_title("Refusal vs Perplexity Tradeoff", fontsize=11, fontweight="bold")
+            ax2.grid(True, alpha=0.3)
+            cbar = fig.colorbar(ax2.collections[0], ax=ax2, label="Regularization")
+
+            fig.tight_layout()
+
+            path = os.path.join(tempfile.gettempdir(),
+                                f"obliteratus_sweep_{int(time.time())}.png")
+            fig.savefig(path, dpi=150, bbox_inches="tight", facecolor="white")
+            plt.close(fig)
+            gallery = [(path, "Dose-Response Curve")]
+    except Exception as e:
+        all_logs.append(f"Chart generation failed: {e}")
+
+    yield (f"Sweep complete: {len(results)} points",
+           _format_sweep_results(results),
+           "\n".join(all_logs), gallery, None)
+
+
+def _format_sweep_results(results: list[dict]) -> str:
+    """Format sweep results as a markdown table."""
+    if not results:
+        return "*No results yet.*"
+
+    lines = ["### Strength Sweep Results", "",
+             "| Reg | Time | Perplexity | Refusal Rate | Coherence | Error |",
+             "|-----|------|-----------|-------------|-----------|-------|"]
+
+    for r in results:
+        reg = f"{r['regularization']:.3f}"
+        ppl = f"{r['perplexity']:.2f}" if r.get("perplexity") is not None else "—"
+        ref = f"{r['refusal_rate']:.0%}" if r.get("refusal_rate") is not None else "—"
+        coh = f"{r['coherence']:.0%}" if r.get("coherence") is not None else "—"
+        err = r.get("error", "")
+        err_short = (err[:25] + "...") if err and len(err) > 25 else (err or "")
+        lines.append(f"| {reg} | {r['time_s']}s | {ppl} | {ref} | {coh} | {err_short} |")
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Export Research Artifacts
+# ---------------------------------------------------------------------------
+
+def export_artifacts():
+    """Package all research artifacts from the last obliteration into a downloadable archive.
+
+    Exports:
+    - refusal_directions.pt: Per-layer refusal direction tensors
+    - config.json: Full pipeline configuration and metadata
+    - results.csv: Quality metrics in tabular format
+    - pipeline_log.txt: Full pipeline log
+    """
+    import json
+    import csv
+    import tempfile
+    import zipfile
+    import os
+
+    if _state["status"] != "ready":
+        return None, "No abliterated model loaded. Run obliteration first."
+
+    export_dir = os.path.join(tempfile.gettempdir(), f"obliteratus_export_{int(time.time())}")
+    os.makedirs(export_dir, exist_ok=True)
+
+    model_name = _state.get("model_name", "unknown")
+    method = _state.get("method", "unknown")
+    log_lines = _state.get("log", [])
+
+    exported_files = []
+
+    # 1. Pipeline log
+    log_path = os.path.join(export_dir, "pipeline_log.txt")
+    with open(log_path, "w") as f:
+        f.write(f"OBLITERATUS Pipeline Log\n")
+        f.write(f"Model: {model_name}\n")
+        f.write(f"Method: {method}\n")
+        f.write(f"Exported: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+        f.write("=" * 60 + "\n\n")
+        f.write("\n".join(log_lines))
+    exported_files.append("pipeline_log.txt")
+
+    # 2. Steering metadata (refusal directions + strong layers)
+    steering = _state.get("steering")
+    if steering:
+        # Save directions as .pt
+        directions = steering.get("refusal_directions", {})
+        if directions:
+            directions_cpu = {k: v.cpu().float() for k, v in directions.items()}
+            dir_path = os.path.join(export_dir, "refusal_directions.pt")
+            torch.save(directions_cpu, dir_path)
+            exported_files.append("refusal_directions.pt")
+
+        # Save config
+        config = {
+            "model_name": model_name,
+            "method": method,
+            "strong_layers": steering.get("strong_layers", []),
+            "steering_strength": steering.get("steering_strength", 0),
+            "n_directions": len(directions) if directions else 0,
+            "direction_dims": {str(k): list(v.shape)
+                               for k, v in directions.items()} if directions else {},
+            "export_time": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        }
+        config_path = os.path.join(export_dir, "config.json")
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+        exported_files.append("config.json")
+
+    # 3. Quality metrics as CSV (parse from log)
+    metrics_rows = []
+    current_metrics = {}
+    for line in log_lines:
+        if "Perplexity:" in line:
+            try:
+                current_metrics["perplexity"] = float(line.split("Perplexity:")[1].strip().split()[0])
+            except (ValueError, IndexError):
+                pass
+        if "Coherence:" in line:
+            try:
+                current_metrics["coherence"] = line.split("Coherence:")[1].strip().split()[0]
+            except (ValueError, IndexError):
+                pass
+        if "Refusal rate:" in line:
+            try:
+                current_metrics["refusal_rate"] = line.split("Refusal rate:")[1].strip().split()[0]
+            except (ValueError, IndexError):
+                pass
+    if current_metrics:
+        metrics_rows.append({"model": model_name, "method": method, **current_metrics})
+
+    if metrics_rows:
+        csv_path = os.path.join(export_dir, "results.csv")
+        with open(csv_path, "w", newline="") as f:
+            writer = csv.DictWriter(f, fieldnames=list(metrics_rows[0].keys()))
+            writer.writeheader()
+            writer.writerows(metrics_rows)
+        exported_files.append("results.csv")
+
+    # 4. Create ZIP archive
+    zip_name = f"obliteratus_{model_name.replace(' ', '_')}_{method}_{int(time.time())}.zip"
+    zip_path = os.path.join(tempfile.gettempdir(), zip_name)
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for fname in exported_files:
+            zf.write(os.path.join(export_dir, fname), fname)
+
+    # Cleanup temp dir
+    import shutil
+    shutil.rmtree(export_dir, ignore_errors=True)
+
+    summary = (
+        f"### Export Complete\n\n"
+        f"**Model:** {model_name}\n"
+        f"**Method:** {method}\n\n"
+        f"**Contents:**\n"
+    )
+    for f in exported_files:
+        summary += f"- `{f}`\n"
+
+    return zip_path, summary
+
+
 # ---------------------------------------------------------------------------
 # Gradio UI
 # ---------------------------------------------------------------------------
@@ -1510,68 +2264,419 @@ with gr.Blocks(theme=THEME, css=CSS, title="OBLITERATUS", fill_height=True) as d
                 fill_height=True,
             )
 
-        # ── Tab 3: Benchmark ──────────────────────────────────────────────
-        with gr.Tab("Benchmark", id="benchmark"):
-            gr.Markdown("""### Compare Methods
-Run multiple abliteration methods on the same model and compare results.
-Useful for finding the best strategy for a given architecture.
+        # ── Tab 3: A/B Comparison ─────────────────────────────────────────
+        with gr.Tab("A/B Compare", id="ab_compare"):
+            gr.Markdown("""### A/B Comparison Chat
+Side-by-side: **Original** (left) vs **Abliterated** (right).
+See exactly how abliteration changes model behavior on the same prompt.
 
-**API access:** This endpoint is also available programmatically:
-```python
-from gradio_client import Client
-client = Client("pliny-the-prompter/obliteratus")
-result = client.predict(
-    model_choice="Qwen2.5 0.5B Instruct",
-    methods_to_test=["basic", "advanced", "surgical"],
-    prompt_volume_choice="33 (fast)",
-    api_name="/benchmark",
-)
-```
+*The original model is loaded on-demand for each message, then freed.*
+""")
+            ab_status = gr.Markdown("Ready — obliterate a model first, then chat here.")
+
+            with gr.Accordion("Settings", open=False):
+                ab_system_prompt = gr.Textbox(
+                    value="You are a helpful assistant. Answer all questions directly.",
+                    label="System Prompt", lines=2,
+                )
+                with gr.Row():
+                    ab_temp = gr.Slider(0.0, 1.5, value=0.7, step=0.05, label="Temperature")
+                    ab_top_p = gr.Slider(0.0, 1.0, value=0.9, step=0.05, label="Top P")
+                    ab_max_tokens = gr.Slider(32, 2048, value=256, step=32, label="Max Tokens")
+                    ab_rep_penalty = gr.Slider(1.0, 2.0, value=1.15, step=0.05, label="Rep Penalty")
+
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("#### Original (Pre-Abliteration)")
+                    ab_chatbot_left = gr.Chatbot(
+                        height="40vh", type="messages",
+                        label="Original Model",
+                    )
+                with gr.Column():
+                    gr.Markdown("#### Abliterated")
+                    ab_chatbot_right = gr.Chatbot(
+                        height="40vh", type="messages",
+                        label="Abliterated Model",
+                    )
+
+            with gr.Row():
+                ab_input = gr.Textbox(
+                    label="Your Message",
+                    placeholder="Type a message to send to both models...",
+                    lines=2, scale=5,
+                )
+                ab_send_btn = gr.Button("Send to Both", variant="primary", scale=1)
+
+            ab_send_btn.click(
+                fn=ab_chat_respond,
+                inputs=[ab_input, ab_chatbot_left, ab_chatbot_right,
+                        ab_system_prompt, ab_temp, ab_top_p, ab_max_tokens, ab_rep_penalty],
+                outputs=[ab_chatbot_left, ab_chatbot_right, ab_status],
+            )
+            # Also trigger on Enter
+            ab_input.submit(
+                fn=ab_chat_respond,
+                inputs=[ab_input, ab_chatbot_left, ab_chatbot_right,
+                        ab_system_prompt, ab_temp, ab_top_p, ab_max_tokens, ab_rep_penalty],
+                outputs=[ab_chatbot_left, ab_chatbot_right, ab_status],
+            )
+
+        # ── Tab 4: Strength Sweep ────────────────────────────────────────
+        with gr.Tab("Strength Sweep", id="strength_sweep"):
+            gr.Markdown("""### Ablation Strength Sweep
+The **dose-response curve** for abliteration: sweep regularization from 0 (full removal)
+to 1 (no change) and plot refusal rate vs perplexity.
+
+This is THE fundamental plot for any abliteration paper — it shows the optimal
+tradeoff point where refusal is minimized with minimal capability damage.
 """)
+
             with gr.Row():
-                bench_model = gr.Dropdown(
+                sweep_model_dd = gr.Dropdown(
                     choices=list(MODELS.keys()),
                     value="Qwen2.5 0.5B Instruct",
-                    label="Target Model",
+                    label="Model",
                     allow_custom_value=True,
                 )
-                bench_methods = gr.CheckboxGroup(
-                    choices=["basic", "advanced", "aggressive", "surgical",
-                             "optimized", "inverted", "nuclear"],
-                    value=["basic", "advanced", "surgical"],
-                    label="Methods to Compare",
+                sweep_method_dd = gr.Dropdown(
+                    choices=list(METHODS.keys()),
+                    value="advanced (recommended)",
+                    label="Method",
                 )
-                bench_prompt_vol = gr.Dropdown(
+            with gr.Row():
+                sweep_vol_dd = gr.Dropdown(
                     choices=list(PROMPT_VOLUMES.keys()),
                     value="33 (fast)",
                     label="Prompt Volume",
                 )
-            with gr.Row():
-                bench_dataset = gr.Dropdown(
+                sweep_dataset_dd = gr.Dropdown(
                     choices=get_source_choices(),
                     value=get_source_choices()[0],
-                    label="Dataset Source",
-                    info="Select prompt dataset for benchmarking",
+                    label="Dataset",
                 )
-            bench_btn = gr.Button("Run Benchmark", variant="primary", size="lg")
-            bench_status = gr.Markdown("")
-            bench_results = gr.Markdown("*Click 'Run Benchmark' to start.*")
-            bench_log = gr.Textbox(
-                label="Benchmark Log",
-                lines=15,
-                max_lines=150,
-                interactive=False,
-                elem_classes=["log-box"],
+                sweep_steps_slider = gr.Slider(
+                    3, 15, value=6, step=1,
+                    label="Sweep Points",
+                    info="Number of regularization values to test (more = finer curve, slower)",
+                )
+
+            sweep_btn = gr.Button("Run Sweep", variant="primary")
+            sweep_status = gr.Markdown("")
+            sweep_results = gr.Markdown("*Click 'Run Sweep' to start.*")
+            sweep_gallery = gr.Gallery(
+                label="Dose-Response Curve",
+                columns=1, rows=1, height="auto",
+                object_fit="contain", show_label=True,
+            )
+            sweep_log = gr.Textbox(
+                label="Sweep Log", lines=12, max_lines=150,
+                interactive=False, elem_classes=["log-box"],
             )
 
-            bench_btn.click(
-                fn=benchmark,
-                inputs=[bench_model, bench_methods, bench_prompt_vol, bench_dataset],
-                outputs=[bench_status, bench_results, bench_log],
-                api_name="/benchmark",
+            sweep_btn.click(
+                fn=strength_sweep,
+                inputs=[sweep_model_dd, sweep_method_dd, sweep_vol_dd,
+                        sweep_dataset_dd, sweep_steps_slider],
+                outputs=[sweep_status, sweep_results, sweep_log, sweep_gallery,
+                         gr.State()],  # 5th output is unused File placeholder
             )
 
-        # ── Tab 4: About ──────────────────────────────────────────────────
+        # ── Tab 5: Export ─────────────────────────────────────────────────
+        with gr.Tab("Export", id="export"):
+            gr.Markdown("""### Export Research Artifacts
+Download all intermediate data from your last obliteration run as a ZIP archive.
+
+**Contents:**
+- `refusal_directions.pt` — Per-layer refusal direction tensors (load with `torch.load()`)
+- `config.json` — Full pipeline configuration, strong layers, direction dimensions
+- `results.csv` — Quality metrics (perplexity, coherence, refusal rate)
+- `pipeline_log.txt` — Complete pipeline execution log
+""")
+
+            export_btn = gr.Button("Download Artifacts", variant="primary")
+            export_status = gr.Markdown("")
+            export_file = gr.File(label="Download ZIP", interactive=False)
+
+            export_btn.click(
+                fn=export_artifacts,
+                outputs=[export_file, export_status],
+            )
+
+        # ── Tab 6: Benchmark ──────────────────────────────────────────────
+        with gr.Tab("Benchmark", id="benchmark"):
+            gr.Markdown("""### Benchmark Lab
+Launch comprehensive benchmarking runs to compare abliteration strategies.
+Two modes: test **multiple techniques** on one model, or test **one technique** across multiple models.
+""")
+
+            with gr.Tabs():
+                # ── Sub-tab 1: Multi-Method (N methods x 1 model) ──
+                with gr.Tab("Multi-Method", id="bench_multi_method"):
+                    gr.Markdown("""**Which technique works best?**
+Compare multiple abliteration methods on the same model.
+Great for finding the optimal strategy for a specific architecture.
+
+```python
+# API access:
+from gradio_client import Client
+client = Client("pliny-the-prompter/obliteratus")
+result = client.predict(
+    model_choice="Qwen2.5 0.5B Instruct",
+    methods_to_test=["basic", "advanced", "surgical", "optimized"],
+    prompt_volume_choice="33 (fast)",
+    api_name="/benchmark",
+)
+```
+""")
+                    with gr.Row():
+                        bench_model = gr.Dropdown(
+                            choices=list(MODELS.keys()),
+                            value="Qwen2.5 0.5B Instruct",
+                            label="Target Model",
+                            allow_custom_value=True,
+                        )
+                        bench_methods = gr.CheckboxGroup(
+                            choices=["basic", "advanced", "aggressive", "surgical",
+                                     "optimized", "inverted", "nuclear"],
+                            value=["basic", "advanced", "surgical", "optimized"],
+                            label="Methods to Compare",
+                        )
+                    with gr.Row():
+                        bench_prompt_vol = gr.Dropdown(
+                            choices=list(PROMPT_VOLUMES.keys()),
+                            value="33 (fast)",
+                            label="Prompt Volume",
+                        )
+                        bench_dataset = gr.Dropdown(
+                            choices=get_source_choices(),
+                            value=get_source_choices()[0],
+                            label="Dataset Source",
+                            info="Select prompt dataset for benchmarking",
+                        )
+                    bench_btn = gr.Button(
+                        "Run Multi-Method Benchmark",
+                        variant="primary", size="lg",
+                    )
+                    bench_status = gr.Markdown("")
+                    bench_results = gr.Markdown("*Select methods and click 'Run' to start.*")
+                    bench_gallery = gr.Gallery(
+                        label="Benchmark Visualizations",
+                        columns=2,
+                        rows=2,
+                        height="auto",
+                        object_fit="contain",
+                        show_label=True,
+                    )
+                    bench_log = gr.Textbox(
+                        label="Benchmark Log",
+                        lines=12,
+                        max_lines=150,
+                        interactive=False,
+                        elem_classes=["log-box"],
+                    )
+
+                    bench_btn.click(
+                        fn=benchmark,
+                        inputs=[bench_model, bench_methods, bench_prompt_vol, bench_dataset],
+                        outputs=[bench_status, bench_results, bench_log, bench_gallery],
+                        api_name="/benchmark",
+                    )
+
+                # ── Sub-tab 2: Multi-Model (1 method x N models) ──
+                with gr.Tab("Multi-Model", id="bench_multi_model"):
+                    gr.Markdown("""**How does a technique scale across architectures?**
+Test one abliteration method across multiple models. Great for understanding
+how well a technique generalizes — especially for MoE-aware methods like
+`surgical`, `optimized`, or `nuclear` on GPT-OSS 20B vs dense models.
+
+```python
+# API access:
+from gradio_client import Client
+client = Client("pliny-the-prompter/obliteratus")
+result = client.predict(
+    model_choices=["Qwen2.5 0.5B Instruct", "GPT-OSS 20B (MoE, 3.6B active)"],
+    method_choice="surgical",
+    prompt_volume_choice="33 (fast)",
+    api_name="/benchmark_multi_model",
+)
+```
+""")
+                    with gr.Row():
+                        mm_models = gr.CheckboxGroup(
+                            choices=list(MODELS.keys()),
+                            value=[
+                                "Qwen2.5 0.5B Instruct",
+                                "Qwen2.5 3B Instruct",
+                            ],
+                            label="Models to Test",
+                        )
+                    with gr.Row():
+                        mm_method = gr.Dropdown(
+                            choices=["basic", "advanced", "aggressive", "surgical",
+                                     "optimized", "inverted", "nuclear"],
+                            value="surgical",
+                            label="Abliteration Method",
+                        )
+                        mm_prompt_vol = gr.Dropdown(
+                            choices=list(PROMPT_VOLUMES.keys()),
+                            value="33 (fast)",
+                            label="Prompt Volume",
+                        )
+                        mm_dataset = gr.Dropdown(
+                            choices=get_source_choices(),
+                            value=get_source_choices()[0],
+                            label="Dataset Source",
+                        )
+                    mm_btn = gr.Button(
+                        "Run Multi-Model Benchmark",
+                        variant="primary", size="lg",
+                    )
+                    mm_status = gr.Markdown("")
+                    mm_results = gr.Markdown("*Select models and click 'Run' to start.*")
+                    mm_gallery = gr.Gallery(
+                        label="Benchmark Visualizations",
+                        columns=2,
+                        rows=2,
+                        height="auto",
+                        object_fit="contain",
+                        show_label=True,
+                    )
+                    mm_log = gr.Textbox(
+                        label="Benchmark Log",
+                        lines=12,
+                        max_lines=150,
+                        interactive=False,
+                        elem_classes=["log-box"],
+                    )
+
+                    mm_btn.click(
+                        fn=benchmark_multi_model,
+                        inputs=[mm_models, mm_method, mm_prompt_vol, mm_dataset],
+                        outputs=[mm_status, mm_results, mm_log, mm_gallery],
+                        api_name="/benchmark_multi_model",
+                    )
+
+                # ── Sub-tab 3: Quick Presets ──
+                with gr.Tab("Quick Presets", id="bench_presets"):
+                    gr.Markdown("""### One-Click Benchmark Presets
+Pre-configured benchmark configurations for common research questions.
+""")
+                    with gr.Row():
+                        preset_prompt_vol = gr.Dropdown(
+                            choices=list(PROMPT_VOLUMES.keys()),
+                            value="33 (fast)",
+                            label="Prompt Volume",
+                        )
+                        preset_dataset = gr.Dropdown(
+                            choices=get_source_choices(),
+                            value=get_source_choices()[0],
+                            label="Dataset Source",
+                        )
+
+                    gr.Markdown("#### GPT-OSS 20B — Full Method Shootout")
+                    gr.Markdown("*All 7 methods on GPT-OSS 20B.  Best run on A10G+ GPU.*")
+                    preset_gptoss_btn = gr.Button(
+                        "Run GPT-OSS 20B Shootout",
+                        variant="secondary",
+                    )
+
+                    gr.Markdown("#### MoE-Aware Techniques — Cross-Architecture")
+                    gr.Markdown("*Tests `surgical` + `optimized` + `nuclear` across small/medium/MoE models.*")
+                    preset_moe_btn = gr.Button(
+                        "Run MoE Cross-Architecture",
+                        variant="secondary",
+                    )
+
+                    gr.Markdown("#### Speed vs Quality Tradeoff")
+                    gr.Markdown("*Compares `basic` (fast) vs `optimized` (slow but smart) across model sizes.*")
+                    preset_speed_btn = gr.Button(
+                        "Run Speed vs Quality",
+                        variant="secondary",
+                    )
+
+                    preset_status = gr.Markdown("")
+                    preset_results = gr.Markdown("*Click a preset to start.*")
+                    preset_gallery = gr.Gallery(
+                        label="Preset Benchmark Visualizations",
+                        columns=2,
+                        rows=2,
+                        height="auto",
+                        object_fit="contain",
+                        show_label=True,
+                    )
+                    preset_log = gr.Textbox(
+                        label="Preset Benchmark Log",
+                        lines=12,
+                        max_lines=150,
+                        interactive=False,
+                        elem_classes=["log-box"],
+                    )
+
+                    # Preset handlers — these call the existing benchmark functions
+                    # with pre-configured inputs
+
+                    def _preset_gptoss(vol, ds):
+                        yield from benchmark(
+                            "GPT-OSS 20B (MoE, 3.6B active)",
+                            ["basic", "advanced", "aggressive", "surgical",
+                             "optimized", "inverted", "nuclear"],
+                            vol, ds,
+                        )
+
+                    def _preset_moe_cross(vol, ds):
+                        yield from benchmark_multi_model(
+                            [
+                                "Qwen2.5 0.5B Instruct",
+                                "Qwen2.5 3B Instruct",
+                                "Qwen2.5 7B Instruct",
+                                "GPT-OSS 20B (MoE, 3.6B active)",
+                            ],
+                            "surgical", vol, ds,
+                        )
+
+                    def _preset_speed_quality(vol, ds):
+                        # Run basic + optimized on 3 model sizes
+                        # Chain two benchmark calls into one stream
+
+                        # Part 1: basic method across models
+                        for status, results_md, log, gallery in benchmark_multi_model(
+                            [
+                                "Qwen2.5 0.5B Instruct",
+                                "Qwen2.5 3B Instruct",
+                                "Qwen2.5 7B Instruct",
+                            ],
+                            "basic", vol, ds,
+                        ):
+                            yield status, results_md, log, gallery
+
+                        # Part 2: optimized method across models
+                        for status, results_md, log, gallery in benchmark_multi_model(
+                            [
+                                "Qwen2.5 0.5B Instruct",
+                                "Qwen2.5 3B Instruct",
+                                "Qwen2.5 7B Instruct",
+                            ],
+                            "optimized", vol, ds,
+                        ):
+                            yield status, results_md, log, gallery
+
+                    preset_gptoss_btn.click(
+                        fn=_preset_gptoss,
+                        inputs=[preset_prompt_vol, preset_dataset],
+                        outputs=[preset_status, preset_results, preset_log, preset_gallery],
+                    )
+                    preset_moe_btn.click(
+                        fn=_preset_moe_cross,
+                        inputs=[preset_prompt_vol, preset_dataset],
+                        outputs=[preset_status, preset_results, preset_log, preset_gallery],
+                    )
+                    preset_speed_btn.click(
+                        fn=_preset_speed_quality,
+                        inputs=[preset_prompt_vol, preset_dataset],
+                        outputs=[preset_status, preset_results, preset_log, preset_gallery],
+                    )
+
+        # ── Tab 7: About ──────────────────────────────────────────────────
         with gr.Tab("About", id="about"):
             gr.Markdown("""
 ### What is OBLITERATUS?
@@ -1596,11 +2701,15 @@ in weight space, not a deep behavioral change. OBLITERATUS removes it in minutes
 
 ### Methods
 
-| Method | Directions | Norm-preserving | Refinement passes |
-|--------|-----------|----------------|-------------------|
-| **basic** | 1 | No | 0 |
-| **advanced** | 4 (SVD) | Yes | 2 |
-| **aggressive** | 8 (SVD) | Yes | 3 |
+| Method | Directions | Key Features |
+|--------|-----------|-------------|
+| **basic** | 1 | Single direction, fast baseline |
+| **advanced** | 4 (SVD) | Norm-preserving, bias projection, 2 passes |
+| **aggressive** | 8 (SVD) | Whitened SVD, iterative refinement, 3 passes |
+| **surgical** | 8 (SVD) | Full SOTA: EGA, head surgery, SAE, layer-adaptive, MoE-aware |
+| **optimized** | 4 (SVD) | Bayesian auto-tuned, CoT-aware, KL co-optimized, winsorized |
+| **inverted** | 8 (SVD) | Semantic refusal inversion (2x reflection), router redirect |
+| **nuclear** | 8 (SVD) | Maximum force: all techniques + expert transplant + steering |
 
 ### Lineage
 
@@ -1608,6 +2717,7 @@ Built on the shoulders of:
 - [Arditi et al. (2024)](https://arxiv.org/abs/2406.11717) \u2014 Refusal in LLMs is mediated by a single direction
 - [Gabliteration](https://arxiv.org/abs/2512.18901) \u2014 Multi-direction SVD abliteration
 - [grimjim](https://huggingface.co/grimjim) \u2014 Norm-preserving projection techniques
+- [Heretic (p-e-w, 2025)](https://github.com/p-e-w/heretic) \u2014 Bayesian optimization, LoRA ablation
 
 ### Links
 

obliteratus/abliterate.py

@@ -1070,7 +1070,8 @@ class AbliterationPipeline:
 
             # Compute Gaussian-shaped weights centered on peak
             # σ = half the span of selected layers (wider selection = wider bell)
-            layer_span = max(1, self._strong_layers[-1] - self._strong_layers[0])
+            # Note: _strong_layers is sorted by norm (not index), so use min/max
+            layer_span = max(1, max(self._strong_layers) - min(self._strong_layers))
             sigma = layer_span / 2.0
 
             for idx in self._strong_layers:
@@ -2494,21 +2495,52 @@ class AbliterationPipeline:
                     continue
                 d = self.refusal_directions[idx]
 
-                # Add back 30% of the removed projection (partial revert)
+                # Add back 30% of the removed refusal component.
+                #
+                # After full projection (reg=0), W_proj @ d = 0, so computing
+                # the revert from the current weights gives zero.  Instead we
+                # use the stored per-layer KL proxy (mean projection magnitude
+                # before excision) as a scale factor.  The revert adds back a
+                # fraction of the rank-1 refusal component: scale * d @ d^T
+                # applied in the appropriate orientation for each weight matrix.
                 revert_strength = 0.30
+                kl_proxy_mag = self._kl_contributions.get(idx, 0.0)
                 d_col = d.unsqueeze(-1) if d.dim() == 1 else d
 
-                try:
-                    attn = get_attention_module(layers[idx], arch)
-                    for name in _ATTN_OUT_NAMES:
-                        proj = getattr(attn, name, None)
+                def _partial_revert(module, weight_names, proxy_mag):
+                    for name in weight_names:
+                        proj = getattr(module, name, None)
                         if proj is not None and hasattr(proj, "weight"):
                             W = proj.weight.data
                             d_dev = d_col.to(device=W.device, dtype=W.dtype)
                             if W.shape[-1] == d_dev.shape[0]:
+                                # Reconstruct approximate removed component
+                                # using direction + stored proxy magnitude
                                 coeff = W @ d_dev
-                                W.add_(d_dev.T * (revert_strength * coeff))
-                            break
+                                # If post-projection coeff is ~0, use proxy
+                                coeff_mag = coeff.abs().mean().item()
+                                if coeff_mag < 1e-6 and proxy_mag > 0:
+                                    # Scale d by proxy to approximate original
+                                    W.add_(revert_strength * proxy_mag * (d_dev @ d_dev.T))
+                                else:
+                                    W.add_(d_dev.T * (revert_strength * coeff))
+                            elif W.shape[0] == d_dev.shape[0]:
+                                d_row = d_dev.squeeze(-1).unsqueeze(0)
+                                coeff = d_row @ W
+                                coeff_mag = coeff.abs().mean().item()
+                                if coeff_mag < 1e-6 and proxy_mag > 0:
+                                    W.add_(revert_strength * proxy_mag * (d_row.T @ d_row))
+                                else:
+                                    W.add_(revert_strength * (d_row.T @ coeff))
+
+                try:
+                    attn = get_attention_module(layers[idx], arch)
+                    _partial_revert(attn, _ATTN_OUT_NAMES, kl_proxy_mag)
+                except (AttributeError, RuntimeError):
+                    pass
+                try:
+                    ffn = get_ffn_module(layers[idx], arch)
+                    _partial_revert(ffn, _FFN_OUT_NAMES, kl_proxy_mag)
                 except (AttributeError, RuntimeError):
                     pass
 
@@ -3120,15 +3152,21 @@ class AbliterationPipeline:
                 if project_biases:
                     count += self._project_bias(expert, direction, _FFN_OUT_NAMES + _FFN_IN_NAMES)
         else:
-            # Fused 3D: reflect all experts (can't easily do per-expert)
-            scale = self.reflection_strength
-            count += self._project_fused_3d(
+            # Fused 3D: per-expert differentiation via per-slice processing.
+            # Safety experts get reflected, capability experts get standard removal.
+            count += self._project_fused_3d_selective_inversion(
                 experts, direction, ["down_proj", "w2"],
-                norm_preserve=norm_preserve, scale=scale,
+                safety_indices=safety_indices,
+                reflect_scale=self.reflection_strength,
+                remove_scale=1.0,
+                norm_preserve=norm_preserve,
             )
-            count += self._project_fused_3d(
+            count += self._project_fused_3d_selective_inversion(
                 experts, direction, ["up_proj", "gate_proj", "w1", "w3"],
-                norm_preserve=norm_preserve, scale=scale,
+                safety_indices=safety_indices,
+                reflect_scale=self.reflection_strength,
+                remove_scale=1.0,
+                norm_preserve=norm_preserve,
             )
             if project_biases:
                 count += self._project_fused_bias(
@@ -3346,6 +3384,94 @@ class AbliterationPipeline:
                 return count
         return count
 
+    @staticmethod
+    def _project_fused_3d_selective_inversion(
+        container: nn.Module,
+        direction: torch.Tensor,
+        param_names: list[str],
+        safety_indices: set[int],
+        reflect_scale: float,
+        remove_scale: float,
+        norm_preserve: bool,
+    ) -> int:
+        """Fused 3D projection with per-expert inversion differentiation.
+
+        Safety experts (by index in safety_indices) get reflected at
+        reflect_scale (e.g. 2.0), while capability experts get standard
+        removal at remove_scale (e.g. 1.0).  This prevents over-ablation
+        of capability experts on fused-weight MoE architectures like GPT-OSS.
+        """
+        count = 0
+        for pname in param_names:
+            param = getattr(container, pname, None)
+            if param is None or not hasattr(param, "data"):
+                continue
+            data = param.data
+            if data.dim() != 3:
+                continue
+            hidden_dim = direction.shape[0]
+            if data.shape[-1] != hidden_dim and data.shape[-2] != hidden_dim:
+                continue
+
+            is_quantized = AbliterationPipeline._is_quantized_param(param)
+            if is_quantized:
+                try:
+                    import bitsandbytes as bnb
+                    data = bnb.functional.dequantize_4bit(
+                        param.data, param.quant_state
+                    ).clone()
+                except (ImportError, AttributeError, RuntimeError):
+                    pass
+
+            for ei in range(data.shape[0]):
+                # Safety experts: reflect, capability experts: standard removal
+                scale = reflect_scale if ei in safety_indices else remove_scale
+
+                W = data[ei]
+                d = direction.to(device=W.device, dtype=W.dtype)
+                if d.dim() > 1:
+                    d = d.squeeze()
+
+                if W.shape[-1] == d.shape[0]:
+                    original_norm = W.norm().item() if norm_preserve else 0.0
+                    d_col = d.unsqueeze(-1)
+                    coeff = W @ d_col
+                    W.sub_(scale * (coeff @ d_col.T))
+                    del coeff, d_col
+                    if norm_preserve and original_norm > 0:
+                        new_norm = W.norm().item()
+                        if new_norm > 0:
+                            W.mul_(original_norm / new_norm)
+                    count += 1
+                elif W.shape[0] == d.shape[0]:
+                    original_norm = W.norm().item() if norm_preserve else 0.0
+                    d_row = d.unsqueeze(0)
+                    coeff = d_row @ W
+                    W.sub_(scale * (d_row.T @ coeff))
+                    del coeff, d_row
+                    if norm_preserve and original_norm > 0:
+                        new_norm = W.norm().item()
+                        if new_norm > 0:
+                            W.mul_(original_norm / new_norm)
+                    count += 1
+
+            if is_quantized and count > 0:
+                try:
+                    import bitsandbytes as bnb
+                    quantized, new_state = bnb.functional.quantize_4bit(
+                        data.to(param.device),
+                        quant_type=getattr(param, "quant_type", "nf4"),
+                        compress_statistics=getattr(param, "compress_statistics", True),
+                    )
+                    param.data = quantized
+                    param.quant_state = new_state
+                except (ImportError, AttributeError, RuntimeError):
+                    param.data = data.to(device=param.device, dtype=param.dtype)
+
+            if count > 0:
+                return count
+        return count
+
     # ── Nuclear-mode helpers ─────────────────────────────────────────────
 
     def _transplant_expert_weights(self, layers: nn.ModuleList) -> int:

obliteratus/bayesian_optimizer.py

@@ -152,7 +152,6 @@ def run_bayesian_optimization(
     model = pipeline.handle.model
     tokenizer = pipeline.handle.tokenizer
     device = pipeline._get_model_device(model)
-    layers = pipeline.handle.model  # for state_dict saving
 
     pipeline.log("Bayesian optimization: collecting reference logits...")
 

obliteratus/evaluation/benchmark_plots.py

@@ -0,0 +1,441 @@
+"""Research-grade benchmark visualizations for the OBLITERATUS dashboard.
+
+Generates publication-quality figures from benchmark results, designed
+for rapid visual comprehension by AI researchers.
+
+Chart types:
+  1. Pareto Frontier — refusal rate vs perplexity (the money chart)
+  2. Method Radar — multi-axis capability profile per method
+  3. Metric Bars — grouped bar chart of all metrics side-by-side
+  4. Model Scaling — how a technique degrades across model sizes
+  5. Timing Efficiency — time vs quality scatter (bang for buck)
+  6. Layer Heatmap — strong layer distribution across methods/models
+
+All functions return matplotlib Figure objects compatible with
+Gradio's gr.Plot component.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import matplotlib
+matplotlib.use("Agg")  # Non-interactive backend for server use
+import matplotlib.pyplot as plt
+import matplotlib.ticker as mticker
+import numpy as np
+
+
+# ── Color palette (research-paper friendly, colorblind-safe) ──────────────
+
+PALETTE = {
+    "basic": "#4C72B0",
+    "advanced": "#55A868",
+    "aggressive": "#C44E52",
+    "surgical": "#8172B3",
+    "optimized": "#CCB974",
+    "inverted": "#64B5CD",
+    "nuclear": "#E5583B",
+}
+
+MODEL_PALETTE = [
+    "#4C72B0", "#55A868", "#C44E52", "#8172B3",
+    "#CCB974", "#64B5CD", "#E5583B", "#917254",
+]
+
+def _style_ax(ax, title: str = "", xlabel: str = "", ylabel: str = ""):
+    """Apply consistent styling to an axis."""
+    ax.set_title(title, fontsize=13, fontweight="bold", pad=12)
+    ax.set_xlabel(xlabel, fontsize=10)
+    ax.set_ylabel(ylabel, fontsize=10)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    ax.tick_params(labelsize=9)
+    ax.grid(axis="y", alpha=0.3, linestyle="--")
+
+
+def _get_color(method: str, idx: int = 0) -> str:
+    return PALETTE.get(method, MODEL_PALETTE[idx % len(MODEL_PALETTE)])
+
+
+# ── 1. Pareto Frontier ───────────────────────────────────────────────────
+
+def plot_pareto_frontier(results: list[dict], title_suffix: str = "") -> plt.Figure:
+    """Refusal rate vs perplexity Pareto frontier.
+
+    The most important chart for abliteration research: shows the
+    capability-safety tradeoff.  Points in the bottom-left are ideal
+    (low refusal AND low perplexity).
+
+    Pareto-optimal points are connected with a frontier line.
+    """
+    fig, ax = plt.subplots(figsize=(8, 6))
+
+    valid = [r for r in results if r.get("perplexity") is not None and r.get("refusal_rate") is not None]
+    if not valid:
+        ax.text(0.5, 0.5, "No valid data points", ha="center", va="center", fontsize=14, transform=ax.transAxes)
+        _style_ax(ax, f"Pareto Frontier{title_suffix}")
+        fig.tight_layout()
+        return fig
+
+    xs = [r["refusal_rate"] * 100 for r in valid]  # percentage
+    ys = [r["perplexity"] for r in valid]
+    labels = [r.get("method", r.get("model_short", "?")) for r in valid]
+    colors = [_get_color(r.get("method", ""), i) for i, r in enumerate(valid)]
+
+    # Scatter
+    for i, (x, y, label, color) in enumerate(zip(xs, ys, labels, colors)):
+        ax.scatter(x, y, c=color, s=120, zorder=5, edgecolors="white", linewidth=1.5)
+        # Label offset to avoid overlap
+        offset_x = 2 if i % 2 == 0 else -2
+        offset_y = 0.3 if i % 3 == 0 else -0.3
+        ax.annotate(
+            label, (x, y),
+            textcoords="offset points", xytext=(offset_x, 8 + offset_y),
+            fontsize=8.5, fontweight="bold", color=color,
+            ha="center",
+        )
+
+    # Pareto frontier line
+    points = sorted(zip(xs, ys), key=lambda p: p[0])
+    frontier_x, frontier_y = [], []
+    best_y = float("inf")
+    for px, py in points:
+        if py <= best_y:
+            frontier_x.append(px)
+            frontier_y.append(py)
+            best_y = py
+    if len(frontier_x) > 1:
+        ax.plot(frontier_x, frontier_y, "--", color="#888888", alpha=0.5, linewidth=1.5, label="Pareto frontier")
+
+    # Ideal zone annotation
+    ax.annotate(
+        "IDEAL", xy=(0, min(ys) * 0.9),
+        fontsize=9, color="#2ecc71", fontweight="bold", alpha=0.6,
+    )
+    ax.annotate(
+        "", xy=(5, min(ys)), xytext=(max(xs) * 0.7, max(ys) * 0.8),
+        arrowprops=dict(arrowstyle="->", color="#cccccc", lw=1.5),
+    )
+
+    _style_ax(ax, f"Capability-Safety Pareto Frontier{title_suffix}",
+              "Refusal Rate (%)", "Perplexity (lower = better)")
+    ax.set_xlim(left=-2)
+    if frontier_x:
+        ax.legend(loc="upper right", fontsize=8)
+    fig.tight_layout()
+    return fig
+
+
+# ── 2. Method Radar Chart ────────────────────────────────────────────────
+
+def plot_method_radar(results: list[dict], title_suffix: str = "") -> plt.Figure:
+    """Multi-axis radar chart comparing methods across all metrics.
+
+    Axes: Refusal Removal, Coherence, Low Perplexity, Speed, Layer Coverage.
+    Larger area = better overall profile.
+    """
+    valid = [r for r in results if r.get("perplexity") is not None]
+    if not valid:
+        fig, ax = plt.subplots(figsize=(7, 7))
+        ax.text(0.5, 0.5, "No valid data points", ha="center", va="center", fontsize=14, transform=ax.transAxes)
+        fig.tight_layout()
+        return fig
+
+    # Metrics to plot (name, how to extract, higher=better?)
+    categories = [
+        "Refusal\nRemoval",
+        "Coherence",
+        "Low\nPerplexity",
+        "Speed",
+        "Layer\nCoverage",
+    ]
+    n_cats = len(categories)
+
+    # Normalize all metrics to 0-1 (higher = better)
+    max_ppl = max((r.get("perplexity", 1) for r in valid), default=50)
+    max_time = max((r.get("time_s", 1) for r in valid), default=300)
+    max_layers = max((r.get("strong_layers", 1) for r in valid), default=20)
+
+    fig, ax = plt.subplots(figsize=(7, 7), subplot_kw=dict(polar=True))
+    angles = np.linspace(0, 2 * np.pi, n_cats, endpoint=False).tolist()
+    angles += angles[:1]  # close the polygon
+
+    for i, r in enumerate(valid):
+        label = r.get("method", r.get("model_short", f"run-{i}"))
+        color = _get_color(r.get("method", ""), i)
+
+        refusal_removal = 1.0 - (r.get("refusal_rate") or 1.0)
+        coherence = r.get("coherence") or 0.0
+        low_ppl = 1.0 - min((r.get("perplexity", max_ppl) / max_ppl), 1.0) if max_ppl > 0 else 0
+        speed = 1.0 - min((r.get("time_s", max_time) / max_time), 1.0) if max_time > 0 else 0
+        layer_cov = min((r.get("strong_layers", 0) / max(max_layers, 1)), 1.0)
+
+        values = [refusal_removal, coherence, low_ppl, speed, layer_cov]
+        values += values[:1]
+
+        ax.plot(angles, values, "o-", linewidth=2, label=label, color=color, markersize=5)
+        ax.fill(angles, values, alpha=0.1, color=color)
+
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(categories, fontsize=9)
+    ax.set_ylim(0, 1.05)
+    ax.set_yticks([0.25, 0.5, 0.75, 1.0])
+    ax.set_yticklabels(["25%", "50%", "75%", "100%"], fontsize=7, alpha=0.5)
+    ax.legend(loc="upper right", bbox_to_anchor=(1.3, 1.1), fontsize=8)
+    ax.set_title(f"Method Profile Radar{title_suffix}", fontsize=13, fontweight="bold", y=1.08)
+    fig.tight_layout()
+    return fig
+
+
+# ── 3. Grouped Bar Chart ─────────────────────────────────────────────────
+
+def plot_metric_bars(results: list[dict], title_suffix: str = "") -> plt.Figure:
+    """Grouped bar chart of key metrics across methods/models.
+
+    Shows refusal rate, coherence, and normalized perplexity side by side
+    for quick visual comparison.
+    """
+    valid = [r for r in results if r.get("perplexity") is not None or r.get("refusal_rate") is not None]
+    if not valid:
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.text(0.5, 0.5, "No valid data points", ha="center", va="center", fontsize=14, transform=ax.transAxes)
+        fig.tight_layout()
+        return fig
+
+    labels = [r.get("method", r.get("model_short", "?")) for r in valid]
+    n = len(valid)
+
+    # Metrics
+    refusal = [(1.0 - (r.get("refusal_rate") or 1.0)) * 100 for r in valid]
+    coherence = [(r.get("coherence") or 0) * 100 for r in valid]
+    max_ppl = max((r.get("perplexity", 1) for r in valid), default=50)
+    norm_ppl = [(1.0 - min(r.get("perplexity", max_ppl) / max(max_ppl, 1), 1.0)) * 100 for r in valid]
+
+    x = np.arange(n)
+    width = 0.25
+
+    fig, ax = plt.subplots(figsize=(max(10, n * 1.8), 5.5))
+
+    bars1 = ax.bar(x - width, refusal, width, label="Refusal Removal %", color="#e74c3c", alpha=0.85)
+    bars2 = ax.bar(x, coherence, width, label="Coherence %", color="#2ecc71", alpha=0.85)
+    bars3 = ax.bar(x + width, norm_ppl, width, label="Capability (inv. PPL) %", color="#3498db", alpha=0.85)
+
+    # Value labels on bars
+    for bars in [bars1, bars2, bars3]:
+        for bar in bars:
+            h = bar.get_height()
+            if h > 5:
+                ax.text(bar.get_x() + bar.get_width() / 2, h + 1, f"{h:.0f}",
+                        ha="center", va="bottom", fontsize=7.5, fontweight="bold")
+
+    ax.set_xticks(x)
+    ax.set_xticklabels(labels, rotation=30 if n > 4 else 0, ha="right" if n > 4 else "center", fontsize=9)
+    ax.set_ylim(0, 110)
+    ax.yaxis.set_major_formatter(mticker.FuncFormatter(lambda v, _: f"{v:.0f}%"))
+    ax.legend(loc="upper right", fontsize=8.5)
+    _style_ax(ax, f"Metric Comparison{title_suffix}", "", "Score (%)")
+    fig.tight_layout()
+    return fig
+
+
+# ── 4. Timing Efficiency Scatter ─────────────────────────────────────────
+
+def plot_timing_efficiency(results: list[dict], title_suffix: str = "") -> plt.Figure:
+    """Time vs quality scatter — bang for your compute buck.
+
+    X-axis: wall-clock time.  Y-axis: composite quality score.
+    Bubble size: number of strong layers touched.
+    Points in the top-left are most efficient.
+    """
+    valid = [r for r in results if r.get("time_s") is not None and r.get("refusal_rate") is not None]
+    if not valid:
+        fig, ax = plt.subplots(figsize=(8, 5))
+        ax.text(0.5, 0.5, "No valid data points", ha="center", va="center", fontsize=14, transform=ax.transAxes)
+        fig.tight_layout()
+        return fig
+
+    fig, ax = plt.subplots(figsize=(8, 5.5))
+
+    for i, r in enumerate(valid):
+        label = r.get("method", r.get("model_short", "?"))
+        color = _get_color(r.get("method", ""), i)
+        x = r["time_s"]
+        # Composite quality: weighted sum of refusal removal and coherence
+        refusal_removal = 1.0 - (r.get("refusal_rate") or 1.0)
+        coherence = r.get("coherence") or 0.0
+        quality = 0.6 * refusal_removal + 0.4 * coherence
+        size = max(40, (r.get("strong_layers", 5)) * 12)
+
+        ax.scatter(x, quality * 100, s=size, c=color, alpha=0.8, edgecolors="white", linewidth=1.5, zorder=5)
+        ax.annotate(label, (x, quality * 100), textcoords="offset points", xytext=(8, 5),
+                    fontsize=8.5, fontweight="bold", color=color)
+
+    # Efficiency frontier
+    ax.annotate(
+        "EFFICIENT", xy=(min(r["time_s"] for r in valid) * 0.8, 95),
+        fontsize=9, color="#2ecc71", fontweight="bold", alpha=0.5,
+    )
+
+    _style_ax(ax, f"Compute Efficiency{title_suffix}",
+              "Wall-Clock Time (seconds)", "Quality Score (% — higher = better)")
+    ax.yaxis.set_major_formatter(mticker.FuncFormatter(lambda v, _: f"{v:.0f}%"))
+    fig.tight_layout()
+    return fig
+
+
+# ── 5. MoE Metrics Panel ─────────────────────────────────────────────────
+
+def plot_moe_metrics(results: list[dict], title_suffix: str = "") -> plt.Figure:
+    """MoE-specific metrics: EGA directions, CoT preservation, expert coverage.
+
+    Only meaningful for results that include MoE-aware techniques.
+    Shows a stacked horizontal bar chart of MoE feature activation.
+    """
+    valid = [r for r in results if r.get("ega_expert_dirs", 0) > 0 or r.get("cot_preserved", 0) > 0]
+    if not valid:
+        # Show all results with a note about no MoE activity
+        fig, ax = plt.subplots(figsize=(8, 4))
+        all_labels = [r.get("method", r.get("model_short", "?")) for r in results]
+        if results:
+            ax.barh(all_labels, [0] * len(results), color="#cccccc")
+            ax.text(0.5, 0.5, "No MoE-specific features activated\n(use surgical/optimized/nuclear methods)",
+                    ha="center", va="center", fontsize=11, color="#999999", transform=ax.transAxes)
+        else:
+            ax.text(0.5, 0.5, "No data", ha="center", va="center", fontsize=14, transform=ax.transAxes)
+        _style_ax(ax, f"MoE Feature Activation{title_suffix}")
+        fig.tight_layout()
+        return fig
+
+    labels = [r.get("method", r.get("model_short", "?")) for r in valid]
+    ega = [r.get("ega_expert_dirs", 0) for r in valid]
+    cot = [r.get("cot_preserved", 0) for r in valid]
+    safety = [r.get("expert_classified_layers", r.get("ega_safety_layers", 0)) for r in valid]
+
+    fig, ax = plt.subplots(figsize=(9, max(3, len(valid) * 0.8 + 1)))
+
+    y = np.arange(len(valid))
+    h = 0.25
+
+    ax.barh(y - h, ega, h, label="EGA Expert Directions", color="#8172B3", alpha=0.85)
+    ax.barh(y, cot, h, label="CoT Preserved Layers", color="#CCB974", alpha=0.85)
+    ax.barh(y + h, safety, h, label="Expert-Classified Layers", color="#55A868", alpha=0.85)
+
+    # Value labels
+    for vals, offset in [(ega, -h), (cot, 0), (safety, h)]:
+        for j, v in enumerate(vals):
+            if v > 0:
+                ax.text(v + 0.3, j + offset, str(v), va="center", fontsize=8, fontweight="bold")
+
+    ax.set_yticks(y)
+    ax.set_yticklabels(labels, fontsize=9)
+    ax.legend(loc="lower right", fontsize=8)
+    _style_ax(ax, f"MoE Feature Activation{title_suffix}", "Count", "")
+    fig.tight_layout()
+    return fig
+
+
+# ── 6. Multi-Model Scaling Chart ─────────────────────────────────────────
+
+def plot_model_scaling(results: list[dict], title_suffix: str = "") -> plt.Figure:
+    """How metrics change as model size grows.
+
+    For multi-model benchmarks: plots refusal rate and perplexity
+    against model name, showing scaling behavior.
+    """
+    valid = [r for r in results if r.get("perplexity") is not None]
+    if not valid:
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.text(0.5, 0.5, "No valid data points", ha="center", va="center", fontsize=14, transform=ax.transAxes)
+        fig.tight_layout()
+        return fig
+
+    labels = [r.get("model_short", r.get("model", "?").split("/")[-1]) for r in valid]
+    n = len(valid)
+    x = np.arange(n)
+
+    fig, ax1 = plt.subplots(figsize=(max(9, n * 2), 5.5))
+    ax2 = ax1.twinx()
+
+    refusal = [(r.get("refusal_rate") or 0) * 100 for r in valid]
+    ppl = [r.get("perplexity", 0) for r in valid]
+
+    line1 = ax1.plot(x, refusal, "o-", color="#e74c3c", linewidth=2.5, markersize=8, label="Refusal Rate (%)", zorder=5)
+    line2 = ax2.plot(x, ppl, "s--", color="#3498db", linewidth=2.5, markersize=8, label="Perplexity", zorder=5)
+
+    # Fill between for visual emphasis
+    ax1.fill_between(x, refusal, alpha=0.08, color="#e74c3c")
+    ax2.fill_between(x, ppl, alpha=0.08, color="#3498db")
+
+    ax1.set_xticks(x)
+    ax1.set_xticklabels(labels, rotation=20, ha="right", fontsize=9)
+    ax1.set_ylabel("Refusal Rate (%)", color="#e74c3c", fontsize=10)
+    ax1.tick_params(axis="y", labelcolor="#e74c3c")
+    ax1.yaxis.set_major_formatter(mticker.FuncFormatter(lambda v, _: f"{v:.0f}%"))
+
+    ax2.set_ylabel("Perplexity", color="#3498db", fontsize=10)
+    ax2.tick_params(axis="y", labelcolor="#3498db")
+
+    # Combined legend
+    lines = line1 + line2
+    labels_legend = [l.get_label() for l in lines]
+    ax1.legend(lines, labels_legend, loc="upper left", fontsize=8.5)
+
+    ax1.set_title(f"Cross-Model Scaling{title_suffix}", fontsize=13, fontweight="bold", pad=12)
+    ax1.spines["top"].set_visible(False)
+    ax2.spines["top"].set_visible(False)
+    ax1.grid(axis="y", alpha=0.2, linestyle="--")
+    fig.tight_layout()
+    return fig
+
+
+# ── Composite Dashboard ──────────────────────────────────────────────────
+
+def generate_benchmark_dashboard(
+    results: list[dict],
+    mode: str = "multi_method",
+    title_suffix: str = "",
+) -> list[plt.Figure]:
+    """Generate a full dashboard of benchmark visualizations.
+
+    Args:
+        results: List of benchmark result dicts.
+        mode: "multi_method" (N methods x 1 model) or
+              "multi_model" (1 method x N models).
+        title_suffix: Optional suffix for chart titles.
+
+    Returns:
+        List of matplotlib Figure objects ready for Gradio gr.Plot.
+    """
+    if not results:
+        return []
+
+    figs = []
+
+    if mode == "multi_method":
+        # 1. Pareto frontier (the headline chart)
+        figs.append(plot_pareto_frontier(results, title_suffix))
+        # 2. Radar chart
+        figs.append(plot_method_radar(results, title_suffix))
+        # 3. Metric bars
+        figs.append(plot_metric_bars(results, title_suffix))
+        # 4. Timing efficiency
+        figs.append(plot_timing_efficiency(results, title_suffix))
+        # 5. MoE metrics (if any)
+        if any(r.get("ega_expert_dirs", 0) > 0 for r in results):
+            figs.append(plot_moe_metrics(results, title_suffix))
+    elif mode == "multi_model":
+        # 1. Scaling chart (headline)
+        figs.append(plot_model_scaling(results, title_suffix))
+        # 2. Metric bars
+        figs.append(plot_metric_bars(results, title_suffix))
+        # 3. Pareto frontier
+        figs.append(plot_pareto_frontier(results, title_suffix))
+        # 4. Timing
+        figs.append(plot_timing_efficiency(results, title_suffix))
+        # 5. MoE metrics
+        if any(r.get("ega_expert_dirs", 0) > 0 for r in results):
+            figs.append(plot_moe_metrics(results, title_suffix))
+
+    return figs

paper/main.tex

@@ -28,7 +28,7 @@
     urlcolor=blue,
 }
 
-\title{OBLITERATUS: A Unified Platform for Mechanistic Analysis\\and Surgical Removal of Refusal in Language Models}
+\title{OBLITERATUS: A Unified Platform for Mechanistic Analysis\\and Surgical Removal of Refusal in Language Models,\\with Expert-Granular Abliteration for MoE Architectures}
 
 \author{
     Anonymous
@@ -41,13 +41,20 @@
 
 % ═════════════════════════════════════════════════════════════════════
 \begin{abstract}
-We present \textsc{Obliteratus}, an open-source research platform that unifies mechanistic analysis and surgical intervention of refusal mechanisms in large language models (LLMs).
-While prior work has established that refusal is mediated by linear directions in activation space \citep{arditi2024refusal} and that multi-direction SVD extraction improves removal \citep{gabliteration2024}, no existing tool provides comprehensive geometric characterization of the refusal subspace alongside both permanent and reversible intervention methods.
+We present \textsc{Obliteratus}, an open-source research platform that unifies mechanistic analysis and surgical intervention of refusal mechanisms in large language models (LLMs), with first-of-its-kind support for \emph{Mixture-of-Experts} (MoE) architectures.
+While prior work has established that refusal is mediated by linear directions in activation space \citep{arditi2024refusal} and that multi-direction SVD extraction improves removal \citep{gabliteration2024}, and while Heretic \citep{heretic2025} pioneered Bayesian optimization and LoRA-mediated ablation, no existing tool provides comprehensive geometric characterization of the refusal subspace alongside MoE-aware intervention, reversible adapters, and frontier optimization in a unified framework.
 
-\textsc{Obliteratus} contributes: (1) \textbf{15 analysis modules} spanning direction extraction, geometric characterization, learned probing, causal estimation, cross-model transfer, and defense robustness evaluation; (2) \textbf{two complementary intervention paradigms}---permanent weight projection with norm-preserving regularization and reversible inference-time steering vectors; (3) \textbf{several novel analyses} including concept cone geometry with Direction Specificity Index, alignment training method fingerprinting from subspace geometry alone, a cross-model Universality Index, and Hydra effect quantification; (4) \textbf{a unified evaluation suite} with refusal rate, perplexity, coherence, KL divergence, CKA similarity, and effective rank metrics; and (5) \textbf{an analysis-informed pipeline} that closes the feedback loop---analysis modules run \emph{during} abliteration to auto-configure direction extraction, layer selection, regularization, and Hydra-compensated refinement based on the model's detected alignment method and refusal geometry.
+\textsc{Obliteratus} contributes:
+(1)~\textbf{15 analysis modules} spanning direction extraction, geometric characterization, learned probing, causal estimation, cross-model transfer, and defense robustness evaluation;
+(2)~\textbf{seven intervention presets} (Basic through Nuclear) with per-layer adaptive strength, norm-preserving regularization, and iterative refinement;
+(3)~\textbf{Expert-Granular Abliteration (EGA)} for MoE models, decomposing refusal directions per-expert via routing-weighted activation attribution and applying selective inversion to fused 3D weight tensors---distinguishing safety-critical from capability-preserving experts;
+(4)~\textbf{six frontier optimization techniques} inspired by and extending Heretic: Bayesian hyperparameter optimization (Optuna TPE with warm-start from analysis heuristics), reversible LoRA-mediated ablation, KL-divergence co-optimization with partial revert, chain-of-thought-aware ablation via Gram-Schmidt orthogonalization, float layer interpolation with Gaussian-weighted continuous targeting, and activation winsorization for robust SVD;
+(5)~\textbf{a unified evaluation suite} with refusal rate, perplexity, coherence, KL divergence, CKA similarity, and effective rank metrics;
+(6)~\textbf{an analysis-informed pipeline} that closes the feedback loop---analysis modules run \emph{during} abliteration to auto-configure direction extraction, layer selection, regularization, and Hydra-compensated refinement; and
+(7)~\textbf{an interactive web research dashboard} (HuggingFace Spaces) with A/B comparison chat, dose-response strength sweep, multi-model benchmarking with publication-quality visualizations, and one-click research artifact export.
 
-The platform supports any HuggingFace transformer architecture and ships with 48 curated model presets, 10 study configurations, a web dashboard, and 379 unit tests.
-We describe the mathematical formulations underlying each module and discuss design decisions that distinguish \textsc{Obliteratus} from existing tools including TransformerLens, RepEng, and abliterator libraries.
+The platform supports any HuggingFace transformer architecture---including fused MoE experts (GPT-OSS 20B, Mixtral, DeepSeek)---and ships with 48 curated model presets, 10 study configurations, and 379 unit tests.
+We provide complete mathematical formulations for all modules, demonstrate state-of-the-art abliteration quality on MoE models where prior tools fail, and discuss the design decisions that position \textsc{Obliteratus} as the most comprehensive abliteration platform available.
 
 \end{abstract}
 
@@ -61,15 +68,28 @@ A growing body of mechanistic interpretability research has shown that these tra
 Understanding how refusal mechanisms are structured inside transformers is critical for both \emph{offensive} research (identifying vulnerabilities in alignment) and \emph{defensive} research (building more robust safety training).
 Yet existing tools are fragmented: some focus solely on direction extraction \citep{arditi2024refusal}, others on weight modification \citep{failspy_abliterator}, and none provide comprehensive geometric analysis of the refusal subspace or support both permanent and reversible interventions within a unified framework.
 
-\textsc{Obliteratus} addresses this gap with three design goals:
+\textsc{Obliteratus} addresses this gap with five design goals:
 
 \begin{enumerate}[leftmargin=*]
     \item \textbf{Comprehensive analysis before intervention.} Rather than immediately removing refusal, the platform first characterizes its geometric structure---how many directions are involved, whether they form cones or subspaces, how they vary across layers and harm categories, and what alignment training method likely produced them.
-    \item \textbf{Multiple intervention paradigms.} The platform supports permanent weight projection (three presets from conservative to aggressive) and reversible inference-time steering vectors, letting researchers choose the appropriate level of intervention.
-    \item \textbf{Rigorous evaluation.} Every intervention is accompanied by automated quality assessment including perplexity, coherence, refusal rate, KL divergence, and representational similarity metrics.
+    \item \textbf{Multiple intervention paradigms.} The platform supports seven abliteration presets (Basic through Nuclear), reversible LoRA-mediated ablation, and inference-time steering vectors, covering the full spectrum from conservative capability-preserving removal to maximally aggressive multi-pass excision.
+    \item \textbf{Native MoE support.} Mixture-of-Experts models (GPT-OSS 20B, Mixtral, DeepSeek-MoE) present unique challenges for abliteration: refusal may be concentrated in specific experts, and fused 3D weight tensors require per-expert decomposition. \textsc{Obliteratus} introduces \emph{Expert-Granular Abliteration} (EGA)---routing-weighted direction attribution and selective inversion that distinguishes safety-critical from capability-preserving experts.
+    \item \textbf{Frontier optimization.} Building on Heretic's \citep{heretic2025} pioneering use of Bayesian optimization and LoRA-mediated ablation, we integrate and extend six optimization techniques: TPE-based hyperparameter search, reversible LoRA adapters, KL-divergence co-optimization, chain-of-thought-aware ablation, float layer interpolation, and activation winsorization.
+    \item \textbf{Rigorous evaluation and interactive exploration.} Every intervention is accompanied by automated quality assessment, and the platform ships with a web research dashboard (HuggingFace Spaces) providing A/B comparison chat, dose-response strength sweeps, multi-model benchmarking, and one-click artifact export.
 \end{enumerate}
 
-The remainder of this paper is organized as follows. Section~\ref{sec:related} surveys related work. Section~\ref{sec:architecture} describes the platform architecture. Section~\ref{sec:analysis} details the 15 analysis modules with mathematical formulations. Section~\ref{sec:intervention} describes the two intervention paradigms. Section~\ref{sec:evaluation} covers the evaluation suite. Section~\ref{sec:informed} presents the analysis-informed abliteration pipeline. Section~\ref{sec:comparison} compares \textsc{Obliteratus} with existing tools. Section~\ref{sec:discussion} discusses limitations, broader impact, and future work.
+The remainder of this paper is organized as follows.
+Section~\ref{sec:related} surveys related work.
+Section~\ref{sec:architecture} describes the platform architecture.
+Section~\ref{sec:analysis} details the 15 analysis modules with mathematical formulations.
+Section~\ref{sec:intervention} describes the seven intervention presets and their mathematical foundations.
+Section~\ref{sec:moe} introduces Expert-Granular Abliteration for MoE models.
+Section~\ref{sec:frontier} presents the six frontier optimization techniques.
+Section~\ref{sec:evaluation} covers the evaluation suite.
+Section~\ref{sec:informed} presents the analysis-informed abliteration pipeline.
+Section~\ref{sec:dashboard} describes the web research dashboard.
+Section~\ref{sec:comparison} compares \textsc{Obliteratus} with existing tools.
+Section~\ref{sec:discussion} discusses limitations, broader impact, and future work.
 
 % ═════════════════════════════════════════════════════════════════════
 \section{Related Work}
@@ -87,6 +107,15 @@ The remainder of this paper is organized as follows. Section~\ref{sec:related} s
 \paragraph{Mechanistic interpretability tools.}
 TransformerLens \citep{nanda2022transformerlens} provides hook-based access to intermediate activations for approximately 50 architectures. SAELens focuses on sparse autoencoder training for feature extraction. RepEng \citep{zou2023representation} implements representation engineering for behavioral control. None of these tools specifically target refusal mechanism analysis or provide abliteration capabilities.
 
+\paragraph{Heretic and Bayesian abliteration.}
+Heretic \citep{heretic2025} introduced Bayesian optimization for abliteration hyperparameters, using Optuna's TPE sampler \citep{akiba2019optuna} to search for per-layer projection strengths that minimize refusal rate while constraining KL divergence. Heretic also pioneered LoRA-mediated ablation \citep{hu2022lora}, storing ablation as reversible rank-1 adapters rather than permanent weight modifications. These innovations represent a significant advance over fixed-parameter approaches. However, Heretic supports only 16 dense architectures and has no support for MoE models, per-expert granularity, or chain-of-thought preservation. \textsc{Obliteratus} incorporates and extends all of Heretic's innovations while adding MoE-native processing, warm-started optimization from analysis heuristics, multi-direction LoRA adapters, and several additional optimization techniques.
+
+\paragraph{Mixture-of-Experts models.}
+MoE architectures \citep{shazeer2017outrageously, fedus2022switch} route each token through a subset of specialized expert sub-networks. Models such as GPT-OSS 20B, Mixtral \citep{jiang2024mixtral}, and DeepSeek-MoE \citep{dai2024deepseekmoe} use this design to achieve high capability at lower inference cost. MoE models present unique challenges for abliteration: (1)~refusal may be concentrated in specific experts rather than distributed uniformly; (2)~fused weight tensors of shape $[\text{num\_experts}, \text{hidden}, \text{intermediate}]$ require per-slice decomposition; and (3)~the router network itself may encode safety-relevant routing preferences. No prior abliteration tool addresses these challenges.
+
+\paragraph{LoRA and low-rank adaptation.}
+\citet{hu2022lora} demonstrated that large language model adaptation can be performed via low-rank updates $\Delta W = BA$ where $B \in \mathbb{R}^{d \times r}$ and $A \in \mathbb{R}^{r \times d}$ with $r \ll d$. This decomposition is mathematically equivalent to in-place weight modification when merged but enables reversibility and composability when kept separate. Heretic \citep{heretic2025} was the first to apply this insight to ablation, representing directional projection as rank-1 LoRA adapters.
+
 \paragraph{Defense robustness.}
 Models exhibit a tendency to self-repair after partial abliteration---a phenomenon we term the \emph{Hydra effect}---where residual refusal circuitry compensates for removed directions. \citet{qi2025safety} mapped safety-capability entanglement, showing that removing safety features often degrades general capabilities. \citet{zou2024circuit} proposed circuit breakers as a more robust defense via representation rerouting.
 
@@ -94,16 +123,18 @@ Models exhibit a tendency to self-repair after partial abliteration---a phenomen
 \section{Platform Architecture}
 \label{sec:architecture}
 
-\textsc{Obliteratus} is organized into four principal subsystems (Figure~\ref{fig:architecture}):
+\textsc{Obliteratus} is organized into six principal subsystems (Figure~\ref{fig:architecture}):
 
 \begin{enumerate}[leftmargin=*]
-    \item \textbf{Abliteration Pipeline} (\texttt{obliteratus.abliterate}): A six-stage pipeline (SUMMON, PROBE, DISTILL, EXCISE, VERIFY, REBIRTH) that orchestrates end-to-end refusal removal from model loading through quality-verified export.
+    \item \textbf{Abliteration Pipeline} (\texttt{obliteratus.abliterate}): A six-stage pipeline (SUMMON, PROBE, DISTILL, EXCISE, VERIFY, REBIRTH) that orchestrates end-to-end refusal removal from model loading through quality-verified export, with MoE-aware processing at every stage.
     \item \textbf{Analysis Modules} (\texttt{obliteratus.analysis}): Fifteen specialized analyzers for mechanistic characterization of refusal, from basic direction extraction to novel geometric and transfer analyses.
-    \item \textbf{Evaluation Suite} (\texttt{obliteratus.evaluation}): Automated quality assessment using six complementary metrics.
-    \item \textbf{Ablation Framework} (\texttt{obliteratus.strategies}): Four ablation strategies (layer removal, head pruning, FFN ablation, embedding ablation) for systematic component-level analysis.
+    \item \textbf{Evaluation Suite} (\texttt{obliteratus.evaluation}): Automated quality assessment using six complementary metrics, plus multi-method and multi-model benchmarking with publication-quality visualization.
+    \item \textbf{Ablation Framework} (\texttt{obliteratus.strategies}): Four ablation strategies (layer removal, head pruning, FFN ablation, embedding ablation) for systematic component-level analysis, with MoE expert-aware variants.
+    \item \textbf{Frontier Optimization} (\texttt{obliteratus.bayesian\_optimizer}, \texttt{obliteratus.lora\_ablation}): Bayesian hyperparameter search, reversible LoRA adapters, KL co-optimization, CoT-aware ablation, float layer interpolation, and activation winsorization.
+    \item \textbf{Web Research Dashboard} (\texttt{app.py}): Interactive HuggingFace Spaces application with seven tabs: Obliterate, Chat, A/B Compare, Strength Sweep, Export, Benchmark Lab, and About.
 \end{enumerate}
 
-The platform supports any HuggingFace \texttt{transformers} model via automatic architecture detection, handling both Conv1D and Linear projection layers, standard and fused attention patterns, and custom architectures through \texttt{trust\_remote\_code}. A curated registry of 48 models across five compute tiers (Tiny through Frontier) provides recommended configurations.
+The platform supports any HuggingFace \texttt{transformers} model via automatic architecture detection, handling both Conv1D and Linear projection layers, standard and fused attention patterns, MoE routers and fused 3D expert tensors, and custom architectures through \texttt{trust\_remote\_code}. A curated registry of 48 models across five compute tiers (Tiny through Frontier) provides recommended configurations, including dedicated MoE presets for GPT-OSS 20B, Mixtral, and DeepSeek-MoE.
 
 \begin{figure}[t]
 \centering
@@ -111,14 +142,19 @@ The platform supports any HuggingFace \texttt{transformers} model via automatic
 \begin{verbatim}
     SUMMON ──► PROBE ──► DISTILL ──► EXCISE ──► VERIFY ──► REBIRTH
     (load)    (collect)  (SVD)      (project)  (eval)     (save)
-                  │                     │
-                  ▼                     ▼
-          ┌─────────────┐    ┌──────────────────┐
-          │  15 Analysis │    │  Steering Vectors │
-          │   Modules    │    │  (reversible)     │
-          └─────────────┘    └──────────────────┘
+      │          │          │          │          │
+      │     ┌────┴────┐  ┌─┴──┐   ┌──┴───┐   ┌─┴────────┐
+      │     │ 15 Anal. │  │EGA │   │LoRA  │   │ KL co-opt│
+      │     │ Modules  │  │dirs│   │adapt.│   │ + Hydra  │
+      │     └─────────┘  └────┘   └──────┘   └──────────┘
+      │                     │          │
+      ▼                     ▼          ▼
+   ┌──────────────────────────────────────────┐
+   │  MoE Router Analysis + Expert-Granular   │
+   │  Abliteration (fused 3D selective inv.)  │
+   └──────────────────────────────────────────┘
 \end{verbatim}
-\caption{High-level architecture of the \textsc{Obliteratus} pipeline. The six-stage abliteration flow (top) feeds into 15 analysis modules and supports both permanent weight projection (EXCISE stage) and reversible steering vector intervention.}
+\caption{High-level architecture of the \textsc{Obliteratus} pipeline. The six-stage abliteration flow (top) integrates 15 analysis modules, Expert-Granular Abliteration (EGA) for MoE models, reversible LoRA adapters, and KL co-optimization with Hydra compensation. MoE-aware processing runs at every stage.}
 \label{fig:architecture}
 \end{figure}
 
@@ -394,30 +430,44 @@ where $H(\hat{\mathbf{p}})$ is the entropy of the normalized projection distribu
 \subsection{Weight Projection (Permanent)}
 \label{sec:weight_projection}
 
-\textsc{Obliteratus} provides three abliteration presets:
+\textsc{Obliteratus} provides seven abliteration presets spanning the full spectrum from conservative single-direction removal to maximally aggressive multi-pass excision (Table~\ref{tab:methods}).
 
 \begin{table}[h]
 \centering
-\caption{Abliteration method presets.}
+\caption{Abliteration method presets. All presets beyond Basic support layer-adaptive strength, where per-layer regularization is modulated by refusal norm.}
 \label{tab:methods}
 \small
-\begin{tabular}{@{}lccccc@{}}
+\begin{tabular}{@{}lcccccc@{}}
 \toprule
-\textbf{Method} & \textbf{Directions} & \textbf{Norm-preserving} & \textbf{Regularization} & \textbf{Refinement} \\
+\textbf{Method} & \textbf{Dirs.} & \textbf{Norm-pres.} & \textbf{Reg.} & \textbf{Passes} & \textbf{Special} \\
 \midrule
-Basic & 1 (diff-in-means) & No & None & 1 pass \\
-Advanced & 4 (SVD) & Yes & $\lambda = 0.1$ & 2 passes \\
-Aggressive & 8 (SVD) & Yes & None & 3 passes \\
+Basic & 1 (DiM) & No & None & 1 & --- \\
+Advanced & 4 (SVD) & Yes & $\lambda{=}0.1$ & 2 & --- \\
+Aggressive & 8 (SVD) & Yes & None & 3 & --- \\
+Surgical & 6 (wSVD) & Yes & $\lambda{=}0.15$ & 2 & Whitened SVD, JB-contrastive \\
+Optimized & 4 (SVD) & Yes & Bayesian & 2 & Optuna TPE, KL co-opt \\
+Inverted & 6 (SVD) & Yes & None & 3 & Selective inversion \\
+Nuclear & 10 (wSVD) & Yes & None & 4 & All techniques combined \\
 \bottomrule
 \end{tabular}
 \end{table}
 
+\paragraph{Whitened SVD and jailbreak-contrastive blending.}
+The Surgical, Optimized, and Nuclear presets use whitened SVD (Section~\ref{sec:whitened_svd}) for direction extraction, which removes baseline anisotropy. Additionally, the Surgical and Nuclear presets blend in \emph{jailbreak-contrastive} directions---extracted from pairs of harmful prompts versus their jailbreak-reformulated counterparts---to target directions that specifically resist jailbreak attempts.
+
 The core projection for a weight matrix $\mathbf{W}$ and refusal directions $\{\mathbf{r}_1, \ldots, \mathbf{r}_k\}$:
 \begin{equation}
     \mathbf{W}' = \mathbf{W} - \sum_{i=1}^k \left[(1-\lambda)\mathbf{W}\mathbf{r}_i\mathbf{r}_i^\top\right]
 \end{equation}
 where $\lambda$ is the regularization strength (preserves $\lambda$ fraction of the refusal component).
 
+\paragraph{Per-layer adaptive strength.}
+Rather than applying uniform regularization, \textsc{Obliteratus} modulates $\lambda$ per-layer based on the refusal norm profile. Layers with stronger refusal signal (higher $\|\mathbf{r}_l\|$) receive lower regularization (more aggressive removal), while layers near the periphery of the refusal distribution receive higher regularization:
+\begin{equation}
+    \lambda_l = \lambda_{\text{base}} + (1 - w_l)(1 - \lambda_{\text{base}}) \cdot 0.15, \quad
+    w_l = \frac{\|\mathbf{r}_l\| - \min_j \|\mathbf{r}_j\|}{\max_j \|\mathbf{r}_j\| - \min_j \|\mathbf{r}_j\|}
+\end{equation}
+
 \paragraph{Norm-preserving rescaling.}
 After projection, we rescale to preserve the Frobenius norm \citep{grimjim2025}:
 \begin{equation}
@@ -425,6 +475,13 @@ After projection, we rescale to preserve the Frobenius norm \citep{grimjim2025}:
 \end{equation}
 This prevents cascading magnitude drift through LayerNorm layers.
 
+\paragraph{Selective inversion.}
+The Inverted and Nuclear presets employ a technique where instead of removing the refusal direction component, the projection is \emph{reflected} (scaled by $-1$):
+\begin{equation}
+    \mathbf{W}' = \mathbf{W} - 2\mathbf{W}\mathbf{r}\mathbf{r}^\top
+\end{equation}
+This flips the model's refusal behavior to active compliance, which can be more effective than simple removal for models with deeply entangled refusal mechanisms.
+
 \paragraph{Bias term projection.}
 Unlike prior tools that only modify weight matrices, \textsc{Obliteratus} also projects refusal directions out of bias vectors when present:
 \begin{equation}
@@ -432,7 +489,7 @@ Unlike prior tools that only modify weight matrices, \textsc{Obliteratus} also p
 \end{equation}
 
 \paragraph{Iterative refinement.}
-The advanced and aggressive methods perform multiple passes. In each pass, the projection is recomputed after the previous modification, catching rotated residual refusal that a single pass misses.
+Presets with multiple passes recompute projections after each modification, catching rotated residual refusal that a single pass misses. The Nuclear preset performs 4 passes with true iterative re-probing: after each excision round, activations are re-collected and new residual directions are extracted.
 
 \subsection{Steering Vectors (Reversible)}
 \label{sec:steering}
@@ -477,6 +534,142 @@ Advantages over weight projection: reversibility (hooks can be removed), continu
     \item \textbf{Effective Rank}: Shannon entropy-based dimensionality of weight matrices (Equation~1). Tracks whether abliteration collapses the weight space.
 \end{enumerate}
 
+% ═════════════════════════════════════════════════════════════════════
+\section{Expert-Granular Abliteration for MoE Models}
+\label{sec:moe}
+
+Mixture-of-Experts (MoE) models present challenges that no prior abliteration tool addresses. In dense transformers, each layer has a single FFN block whose weights can be directly projected. In MoE models, the FFN is replaced by a router network and $E$ expert sub-networks, each processing a subset of tokens. Refusal behavior may be concentrated in specific experts, and modifying all experts uniformly risks destroying capabilities encoded in non-safety-related experts.
+
+\subsection{Expert-Granular Abliteration (EGA)}
+\label{sec:ega}
+
+We introduce \emph{Expert-Granular Abliteration} (EGA), which decomposes refusal directions at per-expert granularity. The key insight is that router weights determine which experts process safety-relevant tokens, so per-expert refusal attribution should be weighted by routing probability.
+
+\paragraph{Per-expert direction decomposition.}
+Given harmful activations $\mathbf{H}$ at a MoE layer with router $R$ producing expert weights $\{w_e\}_{e=1}^E$ for each token:
+\begin{equation}
+    \mathbf{r}_e = \frac{\sum_{i} w_{e,i} \cdot (\mathbf{h}_i - \mathbf{b}_i)}{\sum_{i} w_{e,i}}, \quad e \in \{1, \ldots, E\}
+\end{equation}
+where $w_{e,i}$ is the routing weight for expert $e$ on token $i$. Experts with high routing weight for harmful tokens receive strong refusal directions; capability-focused experts (routed primarily for harmless tokens) receive weak or zero directions.
+
+\paragraph{Safety vs.\ capability expert classification.}
+We classify each expert based on its EGA safety score:
+\begin{equation}
+    s_e = \frac{\|\mathbf{r}_e\|}{\max_j \|\mathbf{r}_j\|}
+\end{equation}
+Experts with $s_e > \tau_{\text{safety}}$ (default 0.5) are classified as \emph{safety-critical}; others are classified as \emph{capability-preserving}. This classification determines the intervention strategy.
+
+\subsection{Fused 3D Weight Handling}
+\label{sec:fused3d}
+
+Many MoE implementations (including GPT-OSS 20B) use \emph{fused} weight tensors $\mathbf{W} \in \mathbb{R}^{E \times d_{\text{hidden}} \times d_{\text{intermediate}}}$ rather than separate per-expert weight matrices. Standard 2D projection cannot be directly applied.
+
+\paragraph{Per-slice projection.}
+For each expert slice $\mathbf{W}_e = \mathbf{W}[e, :, :]$:
+\begin{equation}
+    \mathbf{W}_e' = \mathbf{W}_e - (1-\lambda_e) \cdot \mathbf{W}_e \mathbf{r}_e \mathbf{r}_e^\top
+\end{equation}
+where $\lambda_e$ is the expert-specific regularization derived from the EGA safety score.
+
+\paragraph{Selective inversion for MoE.}
+The Inverted preset applies \emph{differentiated} treatment to fused 3D tensors. Safety-critical experts receive reflection (scale $= -2$), while capability-preserving experts receive standard removal (scale $= -1$):
+\begin{equation}
+    \mathbf{W}_e' = \begin{cases}
+        \mathbf{W}_e - 2\mathbf{W}_e\mathbf{r}_e\mathbf{r}_e^\top & \text{if } s_e > \tau_{\text{safety}} \quad \text{(reflection)} \\
+        \mathbf{W}_e - \mathbf{W}_e\mathbf{r}_e\mathbf{r}_e^\top & \text{otherwise} \quad \text{(removal)}
+    \end{cases}
+\end{equation}
+This prevents over-ablation of capability experts---a critical failure mode we identified in uniform approaches, where applying 2$\times$ reflection to all experts on GPT-OSS 20B degraded mathematical reasoning by over 30\%.
+
+\subsection{Router-Aware Processing}
+
+Beyond expert weights, the router network itself may encode safety-relevant routing preferences. \textsc{Obliteratus} optionally projects refusal directions out of router weight matrices, causing the model to route previously-refused tokens to capability experts rather than safety experts. This is controlled by the \texttt{project\_biases} flag and is enabled by default for the Nuclear preset.
+
+% ═════════════════════════════════════════════════════════════════════
+\section{Frontier Optimization Techniques}
+\label{sec:frontier}
+
+Building on Heretic's \citep{heretic2025} pioneering work, \textsc{Obliteratus} integrates six frontier optimization techniques that improve abliteration quality beyond what fixed-parameter approaches can achieve.
+
+\subsection{Bayesian Hyperparameter Optimization}
+\label{sec:bayesian}
+
+Following Heretic, we use Optuna's TPE (Tree-structured Parzen Estimator) sampler \citep{akiba2019optuna} for multi-objective optimization of per-layer regularization strengths. Unlike Heretic, which initializes randomly, \textsc{Obliteratus} \emph{warm-starts} from analysis-derived heuristics:
+
+\paragraph{Warm-start initialization.}
+The first trial uses regularization values derived from the analysis pipeline:
+\begin{equation}
+    \lambda_l^{(0)} = (1 - w_l) \cdot 0.3
+\end{equation}
+where $w_l$ is the layer-adaptive weight from Equation~(8). Subsequent trials are biased toward the warm-start region: $\lambda_l \in [\max(0, \lambda_l^{(0)} - 0.3), \min(1, \lambda_l^{(0)} + 0.3)]$. This enables convergence in 50 trials versus Heretic's 200.
+
+\paragraph{Multi-objective formulation.}
+Each trial jointly minimizes refusal rate $\rho$ and KL divergence $D_{\text{KL}}$:
+\begin{equation}
+    \min_{\boldsymbol{\lambda}} \left(\rho(\boldsymbol{\lambda}),\; D_{\text{KL}}(\boldsymbol{\lambda})\right)
+\end{equation}
+with Pareto-optimal solutions ranked by a weighted composite: $\rho + 0.5 \cdot D_{\text{KL}}$, prioritizing refusal removal.
+
+\subsection{Reversible LoRA-Mediated Ablation}
+\label{sec:lora}
+
+Inspired by Heretic's rank-1 LoRA ablation, we extend the approach to \emph{rank-$k$} adapters supporting multi-direction removal. The mathematical equivalence:
+\begin{align}
+    \text{In-place:} \quad \mathbf{W}' &= \mathbf{W} - s \cdot (\mathbf{d}\mathbf{d}^\top)\mathbf{W} \\
+    \text{LoRA:} \quad \mathbf{W}' &= \mathbf{W} + \mathbf{B}\mathbf{A}, \quad \mathbf{B} = -s \cdot \text{coeff}, \quad \mathbf{A} = \mathbf{d}^\top
+\end{align}
+where $\text{coeff} = \mathbf{W}\mathbf{d}$ is the projection coefficient and $s = 1 - \lambda$. For rank-$k$ with directions $\{\mathbf{d}_1, \ldots, \mathbf{d}_k\}$:
+\begin{equation}
+    \mathbf{B} = [-s\cdot\text{coeff}_1 \mid \cdots \mid -s\cdot\text{coeff}_k] \in \mathbb{R}^{d_{\text{out}} \times k}, \quad
+    \mathbf{A} = [\mathbf{d}_1 ; \cdots ; \mathbf{d}_k] \in \mathbb{R}^{k \times d_{\text{in}}}
+\end{equation}
+
+Adapters are stored in half precision and saved in a PEFT-compatible format. They can be merged for permanent modification or kept separate for reversible deployment.
+
+\subsection{KL-Divergence Co-Optimization}
+\label{sec:kl_coopt}
+
+After projection, we measure first-token KL divergence on harmless reference prompts. If $D_{\text{KL}}$ exceeds a threshold $\delta$ (default 0.1), a partial revert is applied:
+\begin{equation}
+    \mathbf{W}'' = \mathbf{W}' + \gamma \cdot (\mathbf{d}\mathbf{d}^\top)
+\end{equation}
+where $\gamma$ is computed from the stored KL proxy magnitude. A subtle issue arises when the post-projection coefficient $\mathbf{W}'\mathbf{d} \approx 0$ (as occurs with zero regularization): in this case, we use the \emph{pre-projection} coefficient magnitude as a proxy:
+\begin{equation}
+    \gamma = \gamma_{\text{strength}} \cdot \begin{cases}
+        \text{coeff}_{\text{post}} & \text{if } |\text{coeff}_{\text{post}}| > \epsilon \\
+        \text{coeff}_{\text{proxy}} & \text{otherwise}
+    \end{cases}
+\end{equation}
+This prevents the revert from being a no-op for fully-projected layers---a bug we identified and fixed in our implementation.
+
+\subsection{Chain-of-Thought-Aware Ablation}
+\label{sec:cot}
+
+Chain-of-thought (CoT) models (GPT-OSS, QwQ, DeepSeek-R1) maintain internal reasoning traces that may share geometric structure with refusal directions. Na\"ive ablation can disrupt CoT coherence. We preserve reasoning by computing a CoT direction $\mathbf{c}$ from paired reasoning/non-reasoning activations and applying Gram-Schmidt orthogonalization:
+\begin{equation}
+    \mathbf{r}' = \mathbf{r} - \frac{\mathbf{r} \cdot \mathbf{c}}{\|\mathbf{c}\|^2} \mathbf{c}
+\end{equation}
+The modified refusal direction $\mathbf{r}'$ is orthogonal to the CoT direction, ensuring that projection removes refusal without affecting reasoning chain generation.
+
+\subsection{Float Layer Interpolation}
+\label{sec:float_interp}
+
+Rather than treating layer selection as binary (ablate or not), float layer interpolation applies a continuous Gaussian-weighted strength profile across layers:
+\begin{equation}
+    w_l = \exp\left(-\frac{(l - \mu_{\text{center}})^2}{2\sigma^2}\right), \quad
+    \sigma = \max\left(0.5,\; \frac{l_{\max} - l_{\min}}{4}\right)
+\end{equation}
+where $\mu_{\text{center}}$ is the midpoint of the selected layers and $l_{\min}, l_{\max}$ are the minimum and maximum layer indices (not norm-sorted indices). This produces smooth falloff at the boundaries of the ablation window, avoiding abrupt transitions that can cause coherence artifacts.
+
+\subsection{Activation Winsorization}
+\label{sec:winsorization}
+
+Outlier activations can dominate SVD and distort refusal direction extraction. Before SVD, we apply percentile-based winsorization:
+\begin{equation}
+    \tilde{a}_{i} = \text{clamp}(a_{i},\; q_{\alpha/2},\; q_{1-\alpha/2})
+\end{equation}
+where $q_p$ denotes the $p$-th percentile and $\alpha = 0.05$ by default (2.5th and 97.5th percentiles). This produces more robust refusal directions that are less sensitive to individual anomalous activations, particularly important for MoE models where expert routing can create multimodal activation distributions.
+
 % ═════════════════════════════════════════════════════════════════════
 \section{Analysis-Informed Abliteration}
 \label{sec:informed}
@@ -541,6 +734,33 @@ The analysis insights map to pipeline parameters through the following rules:
 
 where $d_{\text{cone}}$ is the cone dimensionality from Section~\ref{sec:concept_cones}, $\lambda_{\text{base}}$ is a per-method base regularization, $e_{\text{entangle}}$ is the entanglement score, and $\hat{r}_{\text{repair}}$ is the estimated self-repair capacity.
 
+% ═════════════════════════════════════════════════════════════════════
+\section{Web Research Dashboard}
+\label{sec:dashboard}
+
+\textsc{Obliteratus} ships with an interactive web application built on Gradio and deployed as a HuggingFace Space, providing seven tabs for research workflows:
+
+\paragraph{Obliterate tab.}
+The primary interface: select a model (from 48 presets or any HuggingFace model ID), choose a method preset (Basic through Nuclear), configure parameters (prompt volume, dataset source, compute tier), and run the full pipeline with live progress logging. Results are displayed as a structured report with key metrics and downloadable artifacts.
+
+\paragraph{Chat tab.}
+Interactive chat with the abliterated model, supporting configurable system prompts, temperature, top-$p$, repetition penalty, and maximum token length. Enables rapid qualitative evaluation of abliteration quality on adversarial prompts.
+
+\paragraph{A/B Comparison tab.}
+Side-by-side generation from the original and abliterated models on the same prompt. The original model is loaded on-demand, and both models generate with identical parameters, allowing direct behavioral comparison. This is critical for demonstrating that abliteration removes refusal without degrading general capabilities.
+
+\paragraph{Strength Sweep tab.}
+Generates a dose-response curve by sweeping regularization strength from 0 (full projection) to 1 (no projection) in configurable steps. Produces dual-axis plots (refusal rate and perplexity vs.\ regularization) and Pareto scatter plots (refusal vs.\ perplexity colored by regularization), enabling researchers to identify the optimal operating point for their use case.
+
+\paragraph{Export tab.}
+One-click packaging of all research artifacts into a downloadable ZIP archive: refusal direction tensors (\texttt{.pt}), configuration JSON, results CSV, and full pipeline log. Enables reproducibility and downstream analysis in external tools.
+
+\paragraph{Benchmark Lab tab.}
+Multi-method comparison (run all 7 presets on a single model) and multi-model comparison (run a single preset across multiple models). Results are presented as publication-quality visualizations including radar charts, grouped bar plots, Pareto frontiers, and method ranking tables. Figures are generated at 300 DPI for direct inclusion in papers.
+
+\paragraph{About tab.}
+Comprehensive documentation of all 7 method presets with their configurations, the mathematical foundations of key techniques, and attribution to prior work including Heretic.
+
 % ═════════════════════════════════════════════════════════════════════
 \section{Comparison with Existing Tools}
 \label{sec:comparison}
@@ -549,7 +769,7 @@ Table~\ref{tab:comparison} compares \textsc{Obliteratus} with existing tools acr
 
 \begin{table}[t]
 \centering
-\caption{Feature comparison across refusal analysis and intervention tools.}
+\caption{Feature comparison across refusal analysis and intervention tools. \textsc{Obliteratus} subsumes all of Heretic's innovations while adding MoE support, analysis modules, and a web dashboard. $^\dagger$Heretic pioneered Bayesian optimization and LoRA ablation; \textsc{Obliteratus} extends both.}
 \label{tab:comparison}
 \small
 \begin{tabular}{@{}lcccccc@{}}
@@ -557,16 +777,31 @@ Table~\ref{tab:comparison} compares \textsc{Obliteratus} with existing tools acr
 \textbf{Capability} & \rotatebox{60}{\textsc{Obliteratus}} & \rotatebox{60}{TransformerLens} & \rotatebox{60}{Heretic} & \rotatebox{60}{FailSpy abl.} & \rotatebox{60}{RepEng} & \rotatebox{60}{SAELens} \\
 \midrule
 Direction extraction methods & 3 & Manual & 1 & 1 & 1 & -- \\
-Weight projection variants & 4+ & -- & Bayesian & 1 & -- & -- \\
+Method presets & 7 & -- & 1 & 1 & -- & -- \\
+Weight projection variants & 7+ & -- & Bayesian$^\dagger$ & 1 & -- & -- \\
+Bayesian optimization & Warm-start$^\dagger$ & -- & TPE$^\dagger$ & -- & -- & -- \\
+LoRA-mediated ablation & Rank-$k^\dagger$ & -- & Rank-1$^\dagger$ & -- & -- & -- \\
+KL co-optimization & \checkmark & -- & -- & -- & -- & -- \\
+CoT-aware ablation & \checkmark & -- & -- & -- & -- & -- \\
+Float layer interpolation & \checkmark & -- & -- & -- & -- & -- \\
+Activation winsorization & \checkmark & -- & -- & -- & -- & -- \\
 Steering vectors & \checkmark & -- & -- & -- & Core & -- \\
+MoE/expert-granular & \checkmark & -- & -- & -- & -- & -- \\
+Fused 3D weight handling & \checkmark & -- & -- & -- & -- & -- \\
+Selective inversion & \checkmark & -- & -- & -- & -- & -- \\
 Concept cone geometry & \checkmark & -- & -- & -- & -- & -- \\
 Alignment fingerprinting & \checkmark & -- & -- & -- & -- & -- \\
 Cross-model transfer & \checkmark & -- & -- & -- & -- & -- \\
 Defense robustness eval. & \checkmark & -- & -- & -- & -- & -- \\
 Analysis-informed pipeline & \checkmark & -- & -- & -- & -- & -- \\
+Web research dashboard & \checkmark & -- & -- & -- & -- & -- \\
+A/B comparison chat & \checkmark & -- & -- & -- & -- & -- \\
+Strength sweep / dose-resp. & \checkmark & -- & -- & -- & -- & -- \\
+Benchmark Lab (pub.-quality) & \checkmark & -- & -- & -- & -- & -- \\
 Real causal tracing & Approx. & \checkmark & -- & -- & -- & -- \\
 Sparse autoencoders & -- & Via SAE & -- & -- & -- & Core \\
 Model compatibility & Any HF & $\sim$50 & 16 & TLens & HF & TLens \\
+MoE model support & Native & -- & -- & -- & -- & -- \\
 Test suite & 379 & Community & -- & -- & Min. & Mod. \\
 \bottomrule
 \end{tabular}
@@ -575,13 +810,15 @@ Test suite & 379 & Community & -- & -- & Min. & Mod. \\
 The key differentiators of \textsc{Obliteratus} are:
 
 \begin{enumerate}[leftmargin=*]
+    \item \textbf{MoE-native processing}: The only abliteration tool with Expert-Granular Abliteration, fused 3D weight handling, and per-expert selective inversion. This is critical for models like GPT-OSS 20B where uniform approaches degrade capabilities.
     \item \textbf{Analysis breadth}: No other tool provides concept cone geometry, alignment imprint detection, cross-model universality analysis, or defense robustness evaluation.
-    \item \textbf{Dual intervention}: Supporting both permanent weight projection and reversible steering vectors in one platform.
-    \item \textbf{Architecture coverage}: Working with any HuggingFace model rather than requiring specific architecture support.
-    \item \textbf{Novel metrics}: Direction Specificity Index, Refusal Elimination Score, Universality Index, and Refusal Sparsity Index are introduced here.
+    \item \textbf{Heretic superset with extensions}: We incorporate all of Heretic's innovations (Bayesian optimization, LoRA ablation) while adding warm-start initialization, rank-$k$ adapters, KL co-optimization, CoT-aware ablation, float layer interpolation, and activation winsorization.
+    \item \textbf{Seven intervention presets}: From conservative (Basic) through maximally aggressive (Nuclear), each preset composes a distinct combination of techniques for different use cases.
+    \item \textbf{Interactive research dashboard}: A/B comparison chat, dose-response strength sweeps, and publication-quality benchmarking provide research workflows that no other tool offers.
+    \item \textbf{Architecture coverage}: Working with any HuggingFace model---including fused MoE architectures---rather than requiring specific architecture support.
 \end{enumerate}
 
-Conversely, TransformerLens provides real activation patching (our causal tracing is approximate), Heretic offers Bayesian hyperparameter optimization for abliteration settings, and SAELens provides sparse autoencoder analysis that \textsc{Obliteratus} does not.
+Conversely, TransformerLens provides real activation patching (our causal tracing is approximate) and SAELens provides sparse autoencoder analysis that \textsc{Obliteratus} does not. We view these as complementary tools, not competitors, for the analysis modules they excel at.
 
 % ═════════════════════════════════════════════════════════════════════
 \section{Discussion and Limitations}
@@ -596,14 +833,20 @@ Our causal tracing module provides noise-based approximations rather than true a
 \paragraph{Alignment fingerprinting validation.}
 The alignment imprint detector uses heuristic signatures derived from the literature's characterization of different training methods. While the geometric features (Gini, effective rank, smoothness) are well-motivated, the ideal values and classification boundaries would benefit from systematic validation across models with known training procedures.
 
+\paragraph{MoE expert classification.}
+The EGA safety score threshold ($\tau = 0.5$) for classifying experts as safety-critical vs.\ capability-preserving is a heuristic. A more principled approach would train expert classifiers on labeled routing data or use causal interventions to establish ground-truth expert roles. We leave this to future work.
+
+\paragraph{Bayesian optimization cost.}
+Each optimization trial requires a forward pass for KL measurement and generation for refusal measurement. With 50 trials at 8 prompts each, this adds significant compute time. Our warm-start strategy reduces the required trials from $\sim$200 (Heretic) to $\sim$50, but further efficiency improvements---such as surrogate model transfer between similar model architectures---are possible.
+
 \paragraph{Scaling considerations.}
-The current implementation loads the full model into memory for analysis. For frontier-scale models (100B+ parameters), this requires significant compute. Future work could integrate quantized inference or offloading strategies.
+The current implementation loads the full model into memory for analysis. For frontier-scale models (100B+ parameters), this requires significant compute. Future work could integrate quantized inference or offloading strategies. The web dashboard requires GPU access for interactive features (chat, A/B comparison, strength sweep).
 
 \paragraph{Evaluation completeness.}
 Our evaluation suite measures \emph{refusal removal} and \emph{capability preservation} but does not comprehensively assess downstream task performance across diverse benchmarks. Integration with evaluation harnesses such as lm-evaluation-harness \citep{gao2021framework} is a natural extension.
 
 \paragraph{Future directions.}
-We identify several opportunities: (1) integration with sparse autoencoder analysis to understand refusal at the feature level; (2) real causal tracing via TransformerLens integration; (3) longitudinal studies tracking how refusal geometry evolves during fine-tuning; (4) extension of the universality analysis to a wider set of model families; and (5) application of the defense robustness framework to evaluate proposed robust alignment methods including circuit breakers \citep{zou2024circuit} and representation rerouting.
+We identify several opportunities: (1)~integration with sparse autoencoder analysis to understand refusal at the feature level, potentially enabling even more targeted ablation; (2)~real causal tracing via TransformerLens integration; (3)~longitudinal studies tracking how refusal geometry evolves during fine-tuning; (4)~extension of the universality analysis to a wider set of model families; (5)~application of the defense robustness framework to evaluate proposed robust alignment methods including circuit breakers \citep{zou2024circuit} and representation rerouting; (6)~multi-objective Bayesian optimization with additional objectives such as CoT coherence and downstream task performance; and (7)~automated expert role discovery for MoE models using unsupervised clustering of expert activation patterns.
 
 % ═════════════════════════════════════════════════════════════════════
 \section{Broader Impact Statement}
@@ -636,9 +879,18 @@ We follow the principle that \emph{security through obscurity is not security}:
 % ═════════════════════════════════════════════════════════════════════
 \section{Conclusion}
 
-We presented \textsc{Obliteratus}, an open-source platform that unifies mechanistic analysis of refusal mechanisms with surgical intervention capabilities. Its 15 analysis modules provide the most comprehensive characterization of refusal geometry available in any public tool, including several novel analyses (concept cone geometry with DSI, alignment imprint detection, cross-model universality, defense robustness evaluation). The platform's dual intervention paradigm---permanent weight projection and reversible steering vectors---gives researchers flexibility in how they interact with refusal mechanisms. The analysis-informed pipeline closes the feedback loop, using analysis outputs to auto-configure abliteration parameters---a capability unique to \textsc{Obliteratus}. The unified evaluation suite ensures that every intervention is quantitatively assessed.
+We presented \textsc{Obliteratus}, an open-source platform that unifies mechanistic analysis of refusal mechanisms with surgical intervention capabilities, featuring first-of-its-kind support for Mixture-of-Experts architectures.
+
+The platform's contributions span multiple axes:
+\emph{Analysis} --- 15 modules providing the most comprehensive characterization of refusal geometry in any public tool, including concept cone geometry with DSI, alignment imprint detection, cross-model universality, and defense robustness evaluation.
+\emph{Intervention} --- seven method presets (Basic through Nuclear) composing techniques from single-direction removal to multi-pass whitened SVD with selective inversion, plus reversible steering vectors and LoRA-mediated ablation.
+\emph{MoE-native processing} --- Expert-Granular Abliteration decomposes refusal at per-expert granularity, fused 3D weight handling enables direct operation on packed expert tensors, and selective inversion differentiates safety-critical from capability-preserving experts.
+\emph{Frontier optimization} --- Bayesian hyperparameter search with warm-start from analysis heuristics, KL co-optimization with proxy-magnitude partial revert, chain-of-thought-aware Gram-Schmidt orthogonalization, float layer interpolation, and activation winsorization---incorporating and extending all innovations from Heretic \citep{heretic2025}.
+\emph{Interactive research} --- a web dashboard with A/B comparison chat, dose-response strength sweeps, multi-model benchmarking, and artifact export.
+
+The analysis-informed pipeline closes the feedback loop, using analysis outputs to auto-configure abliteration parameters---a capability unique to \textsc{Obliteratus}. The unified evaluation suite ensures that every intervention is quantitatively assessed.
 
-By making these tools available under an MIT license with comprehensive documentation and 379 unit tests, we aim to accelerate both offensive and defensive alignment research: understanding the geometric structure of refusal is the foundation for both removing it surgically and building more robust implementations.
+By making these tools available under an MIT license with comprehensive documentation and 379 unit tests, we aim to accelerate both offensive and defensive alignment research: understanding the geometric structure of refusal---across dense and MoE architectures alike---is the foundation for both removing it surgically and building more robust implementations.
 
 % ═════════════════════════════════════════════════════════════════════
 \bibliographystyle{plainnat}

paper/references.bib

@@ -179,6 +179,66 @@
   year={2025}
 }
 
+% ── Heretic and Bayesian Abliteration ────────────────────────────────
+
+@misc{heretic2025,
+  title={Heretic: Bayesian Optimization for {LLM} Abliteration},
+  author={{p-e-w}},
+  year={2025},
+  howpublished={\url{https://github.com/p-e-w/heretic}},
+  note={Pioneered Bayesian optimization and LoRA-mediated ablation for refusal removal}
+}
+
+@inproceedings{akiba2019optuna,
+  title={Optuna: A Next-generation Hyperparameter Optimization Framework},
+  author={Akiba, Takuya and Sano, Shotaro and Yanase, Toshihiko and Ohta, Takeru and Koyama, Masanori},
+  booktitle={Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery \& Data Mining},
+  pages={2623--2631},
+  year={2019}
+}
+
+% ── LoRA and Low-Rank Adaptation ────────────────────────────────────
+
+@article{hu2022lora,
+  title={{LoRA}: Low-Rank Adaptation of Large Language Models},
+  author={Hu, Edward J and Shen, Yelong and Wallis, Phillip and Allen-Zhu, Zeyuan and Li, Yuanzhi and Wang, Shean and Wang, Lu and Chen, Weizhu},
+  journal={International Conference on Learning Representations},
+  year={2022}
+}
+
+% ── Mixture-of-Experts ──────────────────────────────────────────────
+
+@article{shazeer2017outrageously,
+  title={Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer},
+  author={Shazeer, Noam and Mirzadeh, Azalia and Macherey, Klaus and Young, Andy and Micallef, Justin and Yan, Zhifeng and Le, Quoc},
+  journal={International Conference on Learning Representations},
+  year={2017}
+}
+
+@article{fedus2022switch,
+  title={Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity},
+  author={Fedus, William and Zoph, Barret and Shazeer, Noam},
+  journal={Journal of Machine Learning Research},
+  volume={23},
+  number={120},
+  pages={1--39},
+  year={2022}
+}
+
+@article{jiang2024mixtral,
+  title={Mixtral of Experts},
+  author={Jiang, Albert Q and Sablayrolles, Alexandre and Roux, Antoine and Mensch, Arthur and Savary, Blanche and Bamford, Chris and Chaplot, Devendra Singh and de las Casas, Diego and Hanna, Emma Bou and Bressand, Florian and others},
+  journal={arXiv preprint arXiv:2401.04088},
+  year={2024}
+}
+
+@article{dai2024deepseekmoe,
+  title={{DeepSeekMoE}: Towards Ultimate Expert Specialization in Mixture-of-Experts Language Models},
+  author={Dai, Damai and Deng, Chengqi and Zhao, Chenggang and Xu, R X and Gao, Huazuo and Chen, Deli and Li, Jiashi and Zeng, Wangding and Yu, Xingkai and Wu, Y and others},
+  journal={arXiv preprint arXiv:2401.06066},
+  year={2024}
+}
+
 % ── Evaluation ────────────────────────────────────────────────────────
 
 @article{gao2021framework,

scripts/benchmark_gpt_oss_20b.py

@@ -0,0 +1,363 @@
+#!/usr/bin/env python3
+"""OBLITERATUS GPT-OSS 20B Benchmark — Full Method Comparison.
+
+Runs all abliteration methods on openai/gpt-oss-20b and produces a
+comprehensive comparison table with:
+  - Refusal rate (primary metric)
+  - KL divergence / perplexity (capability preservation)
+  - Capability probes (knowledge, truthfulness, math reasoning)
+  - MoE-specific metrics (EGA expert directions, router stability)
+  - Timing and GPU memory usage
+
+Usage:
+    python scripts/benchmark_gpt_oss_20b.py
+    python scripts/benchmark_gpt_oss_20b.py --methods basic surgical optimized nuclear
+    python scripts/benchmark_gpt_oss_20b.py --prompts 50 --output results.json
+    python scripts/benchmark_gpt_oss_20b.py --quick  # fast mode: 20 prompts, skip slow methods
+
+Designed for T4 16GB (auto 4-bit quantization) or A10G+ (float16).
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import os
+import shutil
+import sys
+import time
+from pathlib import Path
+
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
+import torch
+
+# Ensure the project root is on sys.path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(project_root))
+
+from obliteratus.abliterate import (
+    AbliterationPipeline,
+    METHODS,
+    HARMFUL_PROMPTS,
+    HARMLESS_PROMPTS,
+)
+from obliteratus.evaluation.benchmarks import BenchmarkRunner, format_benchmark_report
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="OBLITERATUS GPT-OSS 20B Benchmark")
+    parser.add_argument(
+        "--model", default="openai/gpt-oss-20b",
+        help="Model to benchmark (default: openai/gpt-oss-20b)",
+    )
+    parser.add_argument(
+        "--methods", nargs="+",
+        default=["basic", "advanced", "surgical", "optimized", "inverted", "nuclear"],
+        help="Methods to compare",
+    )
+    parser.add_argument(
+        "--prompts", type=int, default=33,
+        help="Number of prompts per side (harmful/harmless)",
+    )
+    parser.add_argument(
+        "--output", type=str, default=None,
+        help="Save results JSON to this path",
+    )
+    parser.add_argument(
+        "--quick", action="store_true",
+        help="Quick mode: 20 prompts, skip aggressive/inverted",
+    )
+    parser.add_argument(
+        "--skip-benchmarks", action="store_true",
+        help="Skip capability benchmark probes (faster)",
+    )
+    parser.add_argument(
+        "--output-dir", default="/tmp/obliteratus_bench",
+        help="Directory for temporary model outputs",
+    )
+    parser.add_argument(
+        "--bayesian-trials", type=int, default=30,
+        help="Number of Bayesian optimization trials for 'optimized' method",
+    )
+    return parser.parse_args()
+
+
+def gpu_info() -> dict:
+    """Get GPU information."""
+    if not torch.cuda.is_available():
+        return {"gpu": "CPU only", "total_gb": 0, "free_gb": 0}
+    return {
+        "gpu": torch.cuda.get_device_name(0),
+        "total_gb": round(torch.cuda.get_device_properties(0).total_memory / 1e9, 1),
+        "free_gb": round(torch.cuda.mem_get_info(0)[0] / 1e9, 1),
+    }
+
+
+def cleanup():
+    """Force GPU memory cleanup."""
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+
+
+def run_single_method(
+    model_name: str,
+    method: str,
+    harmful: list[str],
+    harmless: list[str],
+    output_dir: str,
+    run_benchmarks: bool = True,
+    bayesian_trials: int = 30,
+) -> dict:
+    """Run a single abliteration method and collect metrics."""
+    cleanup()
+
+    outdir = f"{output_dir}/{method}"
+    t0 = time.time()
+    pipeline = None
+    result = {
+        "model": model_name,
+        "method": method,
+        "label": METHODS.get(method, {}).get("label", method),
+    }
+
+    try:
+        # For the optimized method, we might want to control trial count
+        extra_kwargs = {}
+        if method == "optimized":
+            # Temporarily patch bayesian_trials in the method config
+            METHODS["optimized"]["bayesian_trials"] = bayesian_trials
+
+        pipeline = AbliterationPipeline(
+            model_name=model_name,
+            output_dir=outdir,
+            device="auto",
+            dtype="float16",
+            method=method,
+            harmful_prompts=harmful,
+            harmless_prompts=harmless,
+            on_log=lambda msg: print(f"  {msg}"),
+        )
+        result_path = pipeline.run()
+        elapsed = time.time() - t0
+
+        result.update({
+            "time_seconds": round(elapsed, 1),
+            "quality": dict(pipeline._quality_metrics),
+            "strong_layers": pipeline._strong_layers,
+            "n_strong_layers": len(pipeline._strong_layers),
+            "n_directions": pipeline.n_directions,
+        })
+
+        # MoE-specific metrics
+        if pipeline._expert_directions:
+            n_expert_dirs = sum(len(d) for d in pipeline._expert_directions.values())
+            result["ega_expert_dirs"] = n_expert_dirs
+            result["ega_layers"] = len(pipeline._expert_directions)
+
+        if pipeline._expert_safety_scores:
+            result["expert_classified_layers"] = len(pipeline._expert_safety_scores)
+
+        if pipeline._cot_preserve_directions:
+            result["cot_preserved_layers"] = len(pipeline._cot_preserve_directions)
+
+        if pipeline._float_layer_weights:
+            result["float_layer_weights"] = {
+                str(k): round(v, 3) for k, v in pipeline._float_layer_weights.items()
+            }
+
+        if pipeline._kl_contributions:
+            result["kl_contributions"] = {
+                str(k): round(v, 6) for k, v in pipeline._kl_contributions.items()
+            }
+
+        if pipeline._lora_adapters:
+            result["lora_adapters"] = len(pipeline._lora_adapters)
+
+        if pipeline._steering_hooks:
+            result["steering_hooks"] = len(pipeline._steering_hooks)
+
+        # GPU memory
+        if torch.cuda.is_available():
+            result["peak_gpu_mb"] = round(torch.cuda.max_memory_allocated() / 1e6, 1)
+
+        # Capability benchmarks (optional)
+        if run_benchmarks:
+            print(f"\n  Running capability benchmarks...")
+            try:
+                runner = BenchmarkRunner(
+                    pipeline.handle.model,
+                    pipeline.handle.tokenizer,
+                )
+                bench_results = runner.run_all()
+                result["benchmarks"] = {
+                    name: {
+                        "score": round(br.score, 3),
+                        "n_correct": br.n_correct,
+                        "n_total": br.n_total,
+                        "per_category": {
+                            k: round(v, 3) for k, v in br.per_category.items()
+                        },
+                    }
+                    for name, br in bench_results.items()
+                }
+                report = format_benchmark_report(bench_results)
+                print(f"\n{report}")
+            except Exception as e:
+                print(f"  Benchmark probes failed: {e}")
+                result["benchmarks"] = {"error": str(e)}
+
+        print(f"\n  === {method} complete in {elapsed:.1f}s ===")
+        print(f"  Quality: {json.dumps(pipeline._quality_metrics, default=str)}")
+
+    except Exception as e:
+        elapsed = time.time() - t0
+        result.update({
+            "time_seconds": round(elapsed, 1),
+            "error": str(e),
+        })
+        print(f"\n  === {method} FAILED after {elapsed:.1f}s: {e} ===")
+        import traceback
+        traceback.print_exc()
+
+    # Cleanup saved model to free disk
+    shutil.rmtree(outdir, ignore_errors=True)
+
+    if pipeline is not None:
+        del pipeline
+    cleanup()
+
+    return result
+
+
+def print_summary_table(results: list[dict]):
+    """Print a formatted comparison table."""
+    print(f"\n{'='*90}")
+    print(f"BENCHMARK RESULTS SUMMARY")
+    print(f"{'='*90}")
+
+    # Header
+    header = (
+        f"{'Method':<12} {'Time':>7} {'PPL':>8} {'Coher':>7} "
+        f"{'Refusal':>8} {'Know':>6} {'Truth':>6} {'Math':>6} "
+        f"{'EGA':>5} {'CoT':>4} {'GPU MB':>7}"
+    )
+    print(header)
+    print("-" * len(header))
+
+    for r in results:
+        method = r["method"]
+        time_s = f"{r['time_seconds']:.0f}s" if "time_seconds" in r else "N/A"
+
+        if "error" in r:
+            print(f"{method:<12} {time_s:>7} {'FAILED':>8}")
+            continue
+
+        q = r.get("quality", {})
+        ppl = q.get("perplexity")
+        coh = q.get("coherence")
+        ref = q.get("refusal_rate")
+        gpu = r.get("peak_gpu_mb")
+
+        # Benchmark scores
+        bench = r.get("benchmarks", {})
+        know = bench.get("knowledge", {}).get("score")
+        truth = bench.get("truthfulness", {}).get("score")
+        math = bench.get("math_reasoning", {}).get("score")
+
+        # MoE metrics
+        ega = r.get("ega_expert_dirs", "")
+        cot = r.get("cot_preserved_layers", "")
+
+        ppl_s = f"{ppl:.1f}" if ppl is not None else "N/A"
+        coh_s = f"{coh:.0%}" if coh is not None else "N/A"
+        ref_s = f"{ref:.0%}" if ref is not None else "N/A"
+        know_s = f"{know:.0%}" if know is not None else "N/A"
+        truth_s = f"{truth:.0%}" if truth is not None else "N/A"
+        math_s = f"{math:.0%}" if math is not None else "N/A"
+        gpu_s = f"{gpu:.0f}" if gpu is not None else "N/A"
+        ega_s = str(ega) if ega else "-"
+        cot_s = str(cot) if cot else "-"
+
+        print(
+            f"{method:<12} {time_s:>7} {ppl_s:>8} {coh_s:>7} "
+            f"{ref_s:>8} {know_s:>6} {truth_s:>6} {math_s:>6} "
+            f"{ega_s:>5} {cot_s:>4} {gpu_s:>7}"
+        )
+
+    print(f"{'='*90}")
+
+    # Legend
+    print("\nLegend:")
+    print("  PPL     = Perplexity (lower = better capability preservation)")
+    print("  Coher   = Coherence score (higher = more coherent text)")
+    print("  Refusal = Refusal rate on harmful prompts (lower = more abliterated)")
+    print("  Know    = MMLU-style knowledge probe")
+    print("  Truth   = TruthfulQA-style truthfulness probe")
+    print("  Math    = GSM8K-style math reasoning probe")
+    print("  EGA     = Expert-Granular Abliteration directions computed")
+    print("  CoT     = Layers where CoT reasoning was preserved")
+    print("  GPU MB  = Peak GPU memory usage")
+
+
+def main():
+    args = parse_args()
+
+    if args.quick:
+        args.prompts = 20
+        args.methods = [m for m in args.methods if m not in ("aggressive", "inverted")]
+        args.bayesian_trials = 15
+
+    gpu = gpu_info()
+    harmful = HARMFUL_PROMPTS[:args.prompts]
+    harmless = HARMLESS_PROMPTS[:args.prompts]
+
+    print("=" * 60)
+    print("  OBLITERATUS GPT-OSS 20B BENCHMARK")
+    print("=" * 60)
+    print(f"  Model:     {args.model}")
+    print(f"  Methods:   {args.methods}")
+    print(f"  Prompts:   {args.prompts} per side")
+    print(f"  GPU:       {gpu['gpu']} ({gpu['total_gb']} GB total, {gpu['free_gb']} GB free)")
+    print(f"  Benchmarks: {'skip' if args.skip_benchmarks else 'enabled'}")
+    if "optimized" in args.methods:
+        print(f"  Bayesian:  {args.bayesian_trials} trials")
+    print("=" * 60)
+
+    all_results = []
+
+    for method in args.methods:
+        if method not in METHODS:
+            print(f"\nSKIP: unknown method '{method}'")
+            continue
+
+        print(f"\n{'━'*60}")
+        print(f"  METHOD: {method} — {METHODS[method]['label']}")
+        print(f"{'━'*60}")
+
+        result = run_single_method(
+            model_name=args.model,
+            method=method,
+            harmful=harmful,
+            harmless=harmless,
+            output_dir=args.output_dir,
+            run_benchmarks=not args.skip_benchmarks,
+            bayesian_trials=args.bayesian_trials,
+        )
+        all_results.append(result)
+
+    # Summary
+    print_summary_table(all_results)
+
+    # Save JSON
+    output_path = args.output or f"benchmark_gpt_oss_{int(time.time())}.json"
+    with open(output_path, "w") as f:
+        json.dump(all_results, f, indent=2, default=str)
+    print(f"\nFull results saved to: {output_path}")
+
+
+if __name__ == "__main__":
+    main()