Release FeatureLens v0.4.0

CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## v0.4.0
+
+### Causal correctness
+- Added an explicit **batched zero-edit reference** to live causal batches so intervention effects are measured against the same execution context as edited rows.
+- Changed the scale dose-response reference to the batched `1×` row. The `1×` row is therefore an exact causal no-op by construction rather than a separately executed baseline comparison.
+- Added execution-context drift diagnostics so any remaining single-forward vs batched-forward numerical difference is reported as instrumentation drift, not causal signal.
+
+### Stronger negative controls
+- Replaced the single live random residual direction with an **8-direction norm-matched random ensemble**.
+- Single-feature, joint feature-set, and 1/3/5 set-size experiments now report random signed mean, mean absolute effect, standard deviation, targeted/random magnitude ratio, and a small-sample empirical tail probability.
+- Updated offline causal and feature-set runners to use the same zero-edit reference and configurable random-control ensembles.
+- Updated report pairing so each targeted intervention is compared with the mean absolute effect of its complete random-control ensemble rather than an arbitrary first control.
+
+### Distributed causality
+- Added **individual-vs-joint ablation decomposition** for 2–5 features.
+- Reports the individual effects, additive expectation, observed joint effect, interaction excess, and normalized non-additivity.
+- The UI explicitly treats non-additivity as a diagnostic, not proof of a direct feature-feature circuit.
+
+### Representation robustness and evidence
+- Added **prompt-wide paraphrase robustness** using max activation per SAE feature across all prompt tokens, alongside the stricter selected-token comparison.
+- Added a live **controlled concept contrast scan** over the seven balanced discovery concepts for one selected feature.
+- Concept contrast results remain exploratory and never overwrite `Offline concept hint` or claim a semantic label from the live scan.
+
+### UI and export
+- Reworked the visual language toward a restrained, print-inspired interface with serif typography, flatter controls, thin rules, and muted chart colors.
+- Replaced intervention radio pills with conventional dropdown controls and realigned the Feature Sets form.
+- Added extra bottom spacing plus an explicit end-of-workbench footer to avoid an app-controlled abrupt cutoff in embedded Spaces.
+- Added **Copy table with headers** actions for every major output table; copied text is tab-separated and begins with the column names.
+- Added a dedicated **Feature evidence** tab for controlled feature-concept contrast tests.
+
+### Validation
+- Expanded the software suite to **29 tests**.
+- Added report tests that verify random-control ensembles are aggregated correctly before paired causal statistics are computed.
+- Rewrote `docs/VALIDATION.md` around exact v0.4 UI labels, including explicit numerical-null, table-copy, adversarial, responsive-layout, and queue tests.
+
 ## v0.3.0
 
 ### Causal measurement

README.md

@@ -13,149 +13,202 @@ license: mit
 
 # FeatureLens — Causal Interpretability Workbench
 
-> **v0.3:** full-continuation causal scoring, joint sparse feature-set interventions, batched 1/3/5-feature ablation sweeps, paraphrase-robustness inspection, and a calmer low-saturation UI.
+> **v0.4:** batch-context causal baselines, 8-direction norm-matched random ensembles, individual-vs-joint interaction decomposition, prompt-wide paraphrase robustness, a controlled live concept contrast, copy-ready tables with headers, and a more restrained research-instrument UI.
 
-**FeatureLens asks one concrete question:**
+**Research question:**
 
 > Do sparse features that predict a concept also causally influence model behaviour?
 
-It uses **Qwen3-1.7B-Base** with the official **Qwen-Scope residual-stream sparse autoencoders (SAEs)**. The live Hugging Face Space inspects sparse residual features and performs controlled interventions; the offline pipeline measures held-out predictiveness, paraphrase stability, single-feature causality, and whether causal influence is distributed across small sparse feature sets.
+FeatureLens uses **Qwen3-1.7B-Base** with **Qwen-Scope residual-stream sparse autoencoders (SAEs)**. It is not an SAE viewer clone: the project separates representation quality, held-out predictiveness, robustness, and causal intervention evidence.
 
-FeatureLens is deliberately **not** an SAE viewer clone and is independent of thesis code and thesis datasets.
+FeatureLens is independent of thesis code and thesis datasets.
 
 ## Evidence ladder
 
-FeatureLens keeps several claims separate:
-
 1. **Reconstruction** — does the SAE represent the residual stream reasonably well?
 2. **Prediction** — does a feature distinguish a controlled concept on held-out paraphrase groups?
-3. **Robustness** — does a sparse representation survive a paraphrase?
-4. **Single-feature causality** — does changing one feature alter downstream behaviour?
-5. **Feature-set causality** — does jointly editing a sparse subspace reveal distributed influence?
-6. **Specificity** — is the effect larger than a norm-matched random residual perturbation?
-7. **Dose-response** — does the behavioural effect change coherently as a feature coefficient is varied?
+3. **Robustness** — does the representation survive rewording locally and prompt-wide?
+4. **Controlled contrast** — does a selected feature prefer one concept group in a balanced live mini-batch?
+5. **Single-feature causality** — does ablation/scaling change downstream probability?
+6. **Dose-response** — does effect size vary coherently with feature coefficient?
+7. **Feature-set causality** — do small sparse subspaces matter more than one feature?
+8. **Non-additivity** — does a joint edit differ from the sum of individual effects?
+9. **Specificity** — are targeted effects larger than norm-matched random residual perturbations?
 
-A feature can be predictive but weakly causal. A feature set can also fail to outperform a matched random perturbation. Both are valid experimental outcomes.
+A high AUROC, high paraphrase overlap, or a large activation is still correlational evidence. Causal evidence comes from downstream change under controlled intervention.
 
-## Live workbench
+## Why v0.4 changed the causal baseline
 
-The Gradio Space supports:
+v0.3 batched multiple residual edits for efficiency, but compared them with a **separately executed baseline**. On real Qwen3 inference this produced a small numerical discrepancy in the nominal `1×` no-edit dose-response row.
 
-- prompt input with an explicit **Prompt tokens** view and selected-token highlight;
-- residual layers **4, 14, 26**;
-- strongest active TopK SAE features and reconstruction diagnostics;
-- feature **ablation**, **scaling**, and **injection**;
-- baseline vs SAE-edited greedy generation;
-- next-token probability shifts and Jensen-Shannon divergence;
-- **full-continuation teacher-forced scoring**, including per-token log-probability rows;
-- deterministic **norm-matched random controls**;
-- a batched single-feature scale dose-response sweep;
-- joint multi-feature ablation/scaling;
-- a batched **1 / 3 / 5 strongest-feature joint-ablation sweep**;
-- an interactive **paraphrase robustness** comparison;
-- early/middle/late representation trajectories;
-- optional empirical feature hints loaded only from real offline artifacts.
+v0.4 therefore includes an explicit **batched zero-edit reference** in causal batches. Every effect inside that batch is measured against the zero-edit row from the **same execution context**.
+
+For the scale dose-response, the `1×` row itself is the no-edit reference:
+
+```text
+0×   = full ablation
+0.5× = half native coefficient
+1×   = batched no-edit reference
+1.5× = 1.5 times native coefficient
+2×   = double native coefficient
+3×   = triple native coefficient
+```
+
+The UI also reports single-forward → batched-null execution drift as a diagnostic instead of silently treating it as a causal effect.
+
+## Random-control ensemble
+
+A single random residual direction can be unusually weak or unusually disruptive by chance. v0.4 replaces the live single control with **8 deterministic norm-matched random directions**.
 
-### Why full-continuation scoring matters
+For a targeted residual delta `Δh`, each control satisfies:
 
-v0.2 measured the first token of a user-supplied target. That is insufficient for a continuation such as `2x` when it tokenizes into multiple tokens.
+```text
+||Δh_random||₂ = ||Δh_SAE||₂
+```
+
+The app reports:
 
-v0.3 concatenates the exact target token IDs to the prompt and scores every target token teacher-forced. It reports:
+- random signed mean effect;
+- random mean absolute effect;
+- random-effect standard deviation;
+- targeted/random magnitude ratio;
+- an exploratory empirical tail probability;
+- equivalent next-token Jensen-Shannon statistics.
 
-- total target sequence log probability;
-- **mean target log probability per token**;
-- SAE-edit deltas;
-- norm-matched random-control deltas;
-- a token-by-token decomposition.
+The live empirical probability is intentionally coarse with only eight controls. The offline benchmark aggregates across held-out tasks and control ensembles.
 
-Mean log probability per target token is the primary length-comparable causal metric used by the v0.3 offline report.
+## Live application
 
-Greedy text may remain unchanged even when these probability-level metrics move. That is expected: deterministic generation changes only after an edit moves a different token across the argmax boundary.
+### Workbench
 
-## Reconstruction-preserving causal edits
+The main workflow supports:
+
+- prompt entry with explicit **Prompt tokens**;
+- layers **4, 14, 26**;
+- token-local SAE inspection;
+- TopK feature activations;
+- reconstruction cosine / NMSE / Top-5 activation mass;
+- feature ablation, scaling, and injection;
+- baseline vs SAE-edited greedy generation;
+- next-token distribution shifts;
+- exact **full-continuation teacher-forced scoring**;
+- per-target-token log-probability decomposition;
+- 8-direction norm-matched random controls;
+- batched scale dose-response.
 
-Let the original residual be `h`, sparse activation `z_i`, and decoder direction `d_i`.
+### Feature sets
+
+FeatureLens can jointly ablate or scale selected active features:
 
 ```text
-ablate:   h' = h - z_i d_i
-scale α:  h' = h + (α - 1) z_i d_i
-inject δ: h' = h + δ d_i
+h' = h + Σᵢ Δzᵢ dᵢ
 ```
 
-FeatureLens patches the **original** residual. It does not replace `h` with the complete SAE reconstruction, so SAE reconstruction error is not introduced as a causal confound.
+The tab includes:
 
-For a feature set `S`, ablation/scaling deltas are summed before patching:
+- manual joint feature-set intervention;
+- automatic **1 / 3 / 5 strongest-feature ablation sweep**;
+- random-ensemble specificity for each set size;
+- **individual-vs-joint non-additivity decomposition** for 2–5 selected features.
+
+For the interaction decomposition, FeatureLens compares:
 
 ```text
-h' = h + Σ_i∈S Δz_i d_i
+observed joint effect
+vs
+sum of individual feature effects
 ```
 
-`inject` is intentionally excluded from multi-feature sets because one shared additive coefficient is not naturally comparable across unrelated decoder directions.
+The difference is reported as an **interaction excess**. A non-zero excess means the downstream response is non-additive under these edits; it does not by itself prove a direct feature-feature circuit.
 
-## Batched causal sweeps
+### Feature evidence
 
-The stronger v0.3 experiments are designed not to multiply ZeroGPU round-trips unnecessarily.
+The **Controlled concept contrast** takes a selected feature and evaluates it on a small balanced batch drawn from the repository's seven controlled concept groups:
 
-### Single-feature scale dose-response
+- code;
+- mathematics;
+- positive sentiment;
+- negative sentiment;
+- French language;
+- factual entities;
+- uncertainty.
 
-The UI evaluates:
+One wording per paraphrase pair is used to reduce near-duplicate inflation. The live scan reports mean activation, median activation, activation rate, and maximum activation by concept.
 
-```text
-0×, 0.5×, 1×, 1.5×, 2×, 3×
-```
+This is an exploratory live feature-evidence tool, **not an automatic semantic label**. The held-out offline AUROC/F1 benchmark remains the stronger claim.
+
+### Paraphrase robustness
+
+v0.4 reports two complementary views:
+
+1. **Selected-token robustness** — TopK Jaccard and sparse cosine at the two manually chosen token positions.
+2. **Prompt-wide robustness** — for each SAE feature, take its maximum activation across all prompt tokens, then compare the two sparse prompt profiles.
+
+The prompt-wide view reduces sensitivity to accidentally comparing semantically different final tokens.
+
+### Layer trajectory
+
+The trajectory view compares SAE reconstruction and sparsity/concentration diagnostics at the same prompt token across layers 4, 14 and 26. It does **not** equate feature IDs across layer-specific SAE dictionaries.
 
-where **0× = ablation** and **1× = no intervention**. All six residual edits are stacked and evaluated in one model forward after the baseline.
+## Copy tables with headers
 
-### Feature-set size sweep
+Every result table that is intended for analysis has an explicit **Copy table with headers** button. The app serializes the displayed data as TSV before copying, so column names are preserved.
 
-The live and offline experiments jointly ablate the strongest active / concept-selected features at:
+The native Dataframe fullscreen control is retained, while the custom copy action avoids relying on browser text selection.
+
+## Reconstruction-preserving edits
+
+Let `h` be the original residual vector, `z_i` the SAE coefficient, and `d_i` the decoder direction.
 
 ```text
-k = 1, 3, 5
+ablate:   h' = h - z_i d_i
+scale α:  h' = h + (α - 1) z_i d_i
+inject δ: h' = h + δ d_i
 ```
 
-Each targeted edit is paired with a random residual perturbation of identical L2 norm. The edited and control conditions are batched together after one baseline forward.
+FeatureLens patches only the decoder-direction **delta** into the original residual. It never replaces the residual with the full SAE reconstruction, avoiding reconstruction error as a causal confound.
 
-This directly tests a plausible failure mode of single-feature interpretability: a concept may be represented across a small sparse subspace rather than one SAE unit.
+## Full-continuation scoring
 
-## Paraphrase robustness explorer
+A target such as `2x` can tokenize into more than one token. FeatureLens concatenates the exact target token IDs to the prompt and scores every target token teacher-forced.
 
-The **Paraphrase robustness** tab compares the same residual layer for an original prompt and a manually supplied rewording. It reports:
+It reports:
 
-- full TopK feature-set Jaccard;
-- sparse activation cosine without densifying the 32,768-wide SAE vector;
-- shared / original-only / paraphrase-only displayed features;
-- side-by-side activation bars.
+- target sequence log probability;
+- mean target log probability per token;
+- per-token log probabilities;
+- targeted edit deltas;
+- random-ensemble comparison.
 
-High overlap is robustness evidence, not a semantic proof about any individual feature.
+Greedy generations can remain identical while these probability-level metrics move. A deterministic text change only occurs after an edit crosses an argmax boundary.
 
 ## Offline experiment
 
-The repository ships a controlled benchmark with:
+The repository ships:
 
-- **224 discovery prompts** across 7 concepts;
-- **112 paraphrase pairs** kept together during splitting;
-- code, mathematics, positive sentiment, negative sentiment, French, factual entities, uncertainty;
+- **224 discovery prompts**;
+- **112 paraphrase pairs**;
+- 7 controlled concepts;
 - **28 separate causal completion tasks**;
-- residual and SAE activation collection at layers 4, 14 and 26.
+- residual/SAE activation collection at layers 4, 14 and 26.
 
-The evaluation computes:
+The offline pipeline computes:
 
 - SAE reconstruction cosine / NMSE;
 - held-out feature/concept AUROC and F1;
-- paraphrase TopK Jaccard and sparse-activation cosine;
-- layer-wise multinomial linear probes on dense residual states;
+- paraphrase TopK Jaccard and sparse activation cosine;
+- dense residual multinomial linear-probe baselines;
 - selected-feature ablation and 2× amplification;
-- exact full-target sequence and mean-per-token log probabilities;
-- next-token probability/rank, JS divergence, and top-1 changes;
-- norm-matched random residual controls;
-- **top-1 / top-3 / top-5 same-layer concept-feature joint ablations**;
+- exact full-target mean log probability per token;
+- next-token JS divergence and top-1 changes;
+- **random-control ensembles** rather than one arbitrary random direction;
+- top-1 / top-3 / top-5 joint feature-set ablations;
 - bootstrap 95% confidence intervals;
-- paired sign-flip tests for SAE-vs-control effect differences.
+- paired sign-flip tests.
 
-Feature selection uses only the **training split**. Held-out AUROC/F1 are reported afterward. Paraphrases from the same pair never cross the train/test boundary.
+Feature selection is performed using the **training split only**. Paraphrase pairs never cross the train/test boundary.
 
-## Run the benchmark
+## Run the offline benchmark
 
 A CUDA machine is strongly recommended.
 
@@ -166,7 +219,7 @@ pip install -r requirements.txt
 python experiments/run_all.py
 ```
 
-The pipeline runs:
+The pipeline is:
 
 ```text
 build_dataset
@@ -177,15 +230,11 @@ build_dataset
 → make_report
 ```
 
-Outputs are materialized under `artifacts/`:
+Outputs are generated under `artifacts/`:
 
 ```text
 artifacts/
 ├── activations/
-│   ├── metadata.json
-│   ├── residuals_layer4.npy
-│   ├── features_layer4.npz
-│   └── ...
 ├── feature_catalog.csv
 ├── layer_metrics.csv
 ├── stability.csv
@@ -194,19 +243,15 @@ artifacts/
 ├── summary.json
 ├── report.md
 └── figures/
-    ├── feature_auroc.png
-    ├��─ layer_diagnostics.png
-    ├── causal_effects.png
-    └── feature_set_effects.png
 ```
 
-`report.md` and `summary.json` are generated from measured results. The repository contains no fabricated benchmark numbers.
+`summary.json` and `report.md` are generated from measured artifacts. No scientific benchmark numbers are fabricated in the repository.
 
-## Hugging Face ZeroGPU deployment
+## Hugging Face deployment
 
-FeatureLens is a **Gradio SDK Space**. The live demo only needs Qwen3-1.7B-Base plus SAE layers **4, 14, 26** rather than all 28 layer checkpoints.
+FeatureLens is a **Gradio SDK Space**. The app keeps SSR disabled and loads only SAE layers 4, 14 and 26 for the live workbench.
 
-Useful environment overrides:
+Useful environment variables:
 
 ```text
 FEATURELENS_MODEL_ID=Qwen/Qwen3-1.7B-Base
@@ -215,9 +260,22 @@ FEATURELENS_LAYERS=4,14,26
 FEATURELENS_EAGER_LOAD=1
 FEATURELENS_SAE_DTYPE=float16
 FEATURELENS_MAX_NEW_TOKENS=32
+FEATURELENS_LIVE_RANDOM_CONTROLS=8
+FEATURELENS_CONTRAST_PROMPTS_PER_CONCEPT=4
 ```
 
-The app uses the `spaces.GPU` decorator when available and falls back to ordinary local execution. SSR is explicitly disabled in `app.py` to avoid the earlier Gradio auth-coroutine warning observed during v0.2 deployment testing.
+## UI design
+
+v0.4 intentionally moves away from a rounded, saturated dashboard aesthetic:
+
+- Times / Liberation Serif-style formal typography;
+- restrained teal, umber, stone, plum, and muted red chart accents;
+- flatter controls and smaller corner radii;
+- aligned intervention forms;
+- explicit section rules instead of pill badges;
+- extra bottom padding and a visible end-of-workbench footer to avoid an abrupt embedded-page cutoff.
+
+The extra bottom spacing cannot control Hugging Face's outer iframe resizing, but it prevents the app itself from ending flush against its final component.
 
 ## Repository layout
 
@@ -257,21 +315,22 @@ python -m compileall -q app.py featurelens experiments scripts
 python scripts/release_check.py
 ```
 
-See [`docs/VALIDATION.md`](docs/VALIDATION.md) for the exact human HF smoke tests. The names in that document match the actual labels in the v0.3 UI.
+See [`docs/VALIDATION.md`](docs/VALIDATION.md). The validation guide uses the **exact labels shown in the v0.4 UI** and defines expected outcomes for normal, edge, and adversarial cases.
 
-## Methodological limitations
+## Limitations
 
-- Qwen-Scope features are sparse directions, not guaranteed monosemantic concepts.
-- A controlled seven-concept benchmark is not a universal feature ontology.
-- Similar TopK sets under paraphrasing do not prove identical semantic meaning.
-- Joint feature ablation can create a larger residual perturbation as `k` increases; norm-matched controls are therefore essential.
-- Full target scoring is teacher-forced: it measures how the edit changes probability assigned to a specified continuation, not free-running sequence probability under sampled generation.
-- Causal effects remain prompt-, layer-, token-, scale-, and task-dependent.
+- SAE features are sparse directions, not guaranteed monosemantic concepts.
+- The live concept contrast is a small controlled diagnostic, not a universal ontology.
+- Prompt-wide max pooling measures feature presence anywhere in the prompt and discards token order.
+- Joint residual edits can be non-additive downstream without implying direct feature-feature interaction.
+- Eight live random controls give only a coarse empirical tail probability.
+- Teacher-forced target scoring measures probability assigned to a specified continuation, not sampled free-running sequence probability.
+- All causal effects remain prompt-, token-, layer-, feature-, and intervention-scale dependent.
 
 ## Resume-ready description
 
 > **FeatureLens — Causal Interpretability Workbench** | PyTorch, Qwen3, Sparse Autoencoders, Mechanistic Interpretability, Gradio  
-> Built an SAE-based interpretability system for Qwen3-1.7B that discovers held-out concept-associated residual features, measures paraphrase stability against dense probes, and causally tests single features and sparse feature sets with full-continuation scoring, dose-response analysis, and norm-matched controls.
+> Built an SAE-based interpretability system for Qwen3-1.7B with held-out concept discovery, local/prompt-wide paraphrase robustness, reconstruction-preserving single and multi-feature interventions, full-continuation scoring, dose-response analysis, non-additivity tests, and norm-matched random-control ensembles.
 
 ## Acknowledgements
 

app.py

@@ -7,69 +7,179 @@ from featurelens.config import SETTINGS
 from featurelens.hf_runtime import gpu
 from featurelens.runtime import RUNTIME
 
-# Muted, low-saturation palette chosen to stay readable in light and dark UI modes.
-MUTED_TEAL = "#6F8F8B"
-MUTED_OCHRE = "#B08D57"
-MUTED_RED = "#A66B6B"
-MUTED_PURPLE = "#8B7EA8"
-MUTED_STONE = "#A59E93"
-
-CSS = """
-.gradio-container { max-width: 1320px !important; }
-.hero { padding: 8px 2px 2px; }
-.hero h1 { margin: 0; font-size: 2.35rem; letter-spacing: -0.045em; }
-.hero p { margin: .35rem 0 0; opacity: .72; font-size: 1rem; }
+# Restrained, print-inspired palette. The app deliberately avoids saturated dashboard colors.
+INK_TEAL = "#708B86"
+INK_UMBER = "#94785D"
+INK_RED = "#986D68"
+INK_PLUM = "#82768F"
+INK_STONE = "#8E8A83"
+INK_BLUEGREY = "#71808A"
+
+CSS = r"""
+.gradio-container {
+  max-width: 1280px !important;
+  padding-bottom: 96px !important;
+  font-family: "Times New Roman", Times, "Liberation Serif", Georgia, serif !important;
+  line-height: 1.45;
+}
+.gradio-container input,
+.gradio-container textarea,
+.gradio-container button,
+.gradio-container select,
+.gradio-container label,
+.gradio-container table {
+  font-family: "Times New Roman", Times, "Liberation Serif", Georgia, serif !important;
+}
+.hero {
+  padding: 12px 2px 4px;
+  border-bottom: 1px solid var(--border-color-primary);
+  margin-bottom: 14px;
+}
+.hero h1 {
+  margin: 0;
+  font-size: 2.15rem;
+  font-weight: 600;
+  letter-spacing: 0;
+}
+.hero .subtitle {
+  margin-top: 3px;
+  font-size: 1.02rem;
+  opacity: .76;
+}
+.hero .metadata {
+  margin-top: 8px;
+  font-size: .82rem;
+  opacity: .62;
+  letter-spacing: .015em;
+}
 .research-q {
-  border-left: 4px solid #6F8F8B;
+  margin: 12px 0 16px;
   padding: 10px 14px;
-  margin: 10px 0 14px;
-  border-radius: 0 10px 10px 0;
+  border-left: 3px solid #708B86;
+  border-top: 1px solid var(--border-color-primary);
+  border-bottom: 1px solid var(--border-color-primary);
   background: var(--background-fill-secondary);
 }
-.badges { display:flex; flex-wrap:wrap; gap:7px; margin:8px 0 3px; }
-.badge {
-  border:1px solid var(--border-color-primary);
-  background:var(--background-fill-secondary);
-  border-radius:999px;
-  padding:4px 9px;
-  font-size:12px;
+.section-rule {
+  margin: 18px 0 10px;
+  padding-top: 8px;
+  border-top: 1px solid var(--border-color-primary);
+  font-variant: small-caps;
+  letter-spacing: .055em;
+  font-size: .88rem;
+  opacity: .72;
 }
-.step {
-  font-size: .78rem;
-  text-transform: uppercase;
-  letter-spacing:.09em;
-  opacity:.66;
-  font-weight:700;
-  margin-top:2px;
+.token-wrap {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 5px;
+  padding: 7px 2px 13px;
+  line-height: 1.9;
 }
-.token-wrap { display:flex; flex-wrap:wrap; gap:5px; padding:6px 2px 10px; line-height:1.7; }
 .token {
-  background:var(--background-fill-secondary);
-  border:1px solid var(--border-color-primary);
-  border-radius:7px;
-  padding:2px 7px;
-  font-family:ui-monospace,SFMono-Regular,monospace;
-  font-size:12px;
+  background: var(--background-fill-secondary);
+  border: 1px solid var(--border-color-primary);
+  border-radius: 3px;
+  padding: 2px 7px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace !important;
+  font-size: 12px;
+}
+.token.selected {
+  border: 2px solid #708B86;
+  font-weight: 700;
+}
+.token sup { opacity: .55; margin-right: 4px; }
+.small-note { opacity: .70; font-size: 12px; }
+.instrument-note {
+  border: 1px solid var(--border-color-primary);
+  border-radius: 4px;
+  padding: 9px 11px;
+  background: var(--background-fill-secondary);
+  margin: 5px 0 10px;
+}
+.copy-row { margin-top: -5px; }
+.copy-row button { min-height: 31px !important; }
+.gradio-container button {
+  border-radius: 4px !important;
+  font-weight: 600 !important;
+}
+.gradio-container .form,
+.gradio-container .block {
+  border-radius: 4px !important;
+}
+.gradio-container textarea,
+.gradio-container input {
+  border-radius: 3px !important;
 }
-.token.selected { border:2px solid #7FA39F; font-weight:650; }
-.token sup { opacity:.55; margin-right:4px; }
-.small-note { opacity:.68; font-size:12px; }
-.callout {
-  border:1px solid var(--border-color-primary);
-  background:var(--background-fill-secondary);
-  border-radius:12px;
-  padding:10px 12px;
+.form-note {
+  margin-top: -3px;
+  margin-bottom: 8px;
+  font-size: .84rem;
+  opacity: .70;
 }
-.metric-note { opacity:.78; }
+.classic-footer {
+  margin-top: 36px;
+  padding: 18px 2px 42px;
+  border-top: 1px solid var(--border-color-primary);
+  opacity: .62;
+  font-size: .82rem;
+  min-height: 92px;
+}
+/* Add breathing room below tabs in embedded Hugging Face iframes. */
+.tabs, .tabitem { padding-bottom: 18px !important; }
 """
 
-THEME = gr.themes.Soft(primary_hue="teal", secondary_hue="stone", neutral_hue="stone")
+THEME = gr.themes.Base(
+    primary_hue="teal",
+    secondary_hue="stone",
+    neutral_hue="stone",
+    radius_size="sm",
+    font=("Times New Roman", "Times", "Liberation Serif", "serif"),
+    font_mono=("Liberation Mono", "Consolas", "monospace"),
+)
+
+COPY_JS = r"""
+(text) => {
+  const value = text || "";
+  const fallback = () => {
+    const node = document.createElement("textarea");
+    node.value = value;
+    node.style.position = "fixed";
+    node.style.opacity = "0";
+    document.body.appendChild(node);
+    node.focus();
+    node.select();
+    document.execCommand("copy");
+    document.body.removeChild(node);
+  };
+  if (navigator.clipboard && navigator.clipboard.writeText) {
+    navigator.clipboard.writeText(value).catch(fallback);
+  } else {
+    fallback();
+  }
+  return [];
+}
+"""
 
 
 def _raise_ui_error(exc: Exception) -> None:
     raise gr.Error(f"{type(exc).__name__}: {exc}") from exc
 
 
+def _tsv(frame: pd.DataFrame) -> str:
+    if frame is None or frame.empty:
+        return ""
+    return frame.to_csv(sep="\t", index=False, lineterminator="\n")
+
+
+def _copy_button(label: str = "Copy table with headers") -> gr.Button:
+    return gr.Button(label, size="sm", variant="secondary")
+
+
+def _bind_copy(button: gr.Button, source: gr.Textbox) -> None:
+    button.click(fn=None, inputs=[source], outputs=None, js=COPY_JS, queue=False)
+
+
 def _analysis_metrics_markdown(result) -> str:
     return (
         "#### Analysis metrics\n"
@@ -82,6 +192,10 @@ def _analysis_metrics_markdown(result) -> str:
 
 
 def _intervention_metrics_markdown(result) -> str:
+    drift = f"Execution-context null drift — JS: **{result.execution_drift_js:.2e}**"
+    if result.execution_drift_mean_logprob is not None:
+        drift += f" · mean log p/token: **{result.execution_drift_mean_logprob:+.2e}**"
+
     target = (
         "No target continuation supplied. The causal comparison therefore uses only "
         "next-token Jensen-Shannon divergence."
@@ -92,29 +206,31 @@ def _intervention_metrics_markdown(result) -> str:
             f"**Target continuation:** {result.target_token_count} token(s): {tokens}  \n"
             f"Sequence log p — baseline: **{result.baseline_sequence_logprob:.4f}** · "
             f"SAE edit: **{result.modified_sequence_logprob:.4f}** · "
-            f"random control: **{result.random_sequence_logprob:.4f}**  \n"
+            f"random-ensemble mean: **{result.random_sequence_logprob:.4f}**  \n"
             f"SAE Δ sequence log p: **{result.sequence_logprob_delta:+.4f}** · "
-            f"random Δ: **{result.random_sequence_logprob_delta:+.4f}**  \n"
+            f"random signed mean Δ: **{result.random_sequence_logprob_delta:+.4f}**  \n"
             f"SAE Δ mean log p/token: **{result.mean_logprob_delta:+.4f}** · "
-            f"random Δ: **{result.random_mean_logprob_delta:+.4f}** · "
-            f"specificity ratio: **{result.target_specificity_ratio:.2f}×**"
+            f"random mean |Δ|: **{result.random_abs_mean_logprob_delta:.4f}** ± **{result.random_mean_logprob_std:.4f}** · "
+            f"magnitude ratio: **{result.target_specificity_ratio:.2f}×** · "
+            f"empirical tail p: **{result.target_empirical_p:.3f}**"
         )
     inactive = ""
     if abs(result.feature_activation) < 1e-12:
         inactive = (
-            "  \n⚠️ **Selected feature is inactive at this prompt token.** Ablate/scale produces "
-            "a zero feature delta; use `inject` to test the decoder direction directly."
+            "  \n**Inactive feature:** ablate/scale has zero coefficient delta here; "
+            "use `inject` only when you intentionally want a decoder-direction steering test."
         )
     return (
         f"Original feature activation: **{result.feature_activation:.4f}** · "
         f"Δ coefficient: **{result.delta_activation:+.4f}**  \n"
         f"Perturbation L2: **{result.perturbation_norm:.4f}**  \n"
         f"Next-token JS: **{result.js_divergence:.6f}** · "
-        f"random-control JS: **{result.random_js_divergence:.6f}** · "
-        f"JS specificity: **{result.js_specificity_ratio:.2f}×**  \n\n"
-        f"{target}{inactive}  \n\n"
-        "_Greedy generations can remain identical even when probability-level causal metrics move; "
-        "an edit must cross an argmax boundary before deterministic text changes._"
+        f"random ensemble ({result.random_control_count}) mean JS: **{result.random_js_divergence:.6f}** "
+        f"± **{result.random_js_std:.6f}** · ratio: **{result.js_specificity_ratio:.2f}×** · "
+        f"empirical tail p: **{result.js_empirical_p:.3f}**  \n"
+        f"{drift}  \n\n{target}{inactive}  \n\n"
+        "_Greedy text may remain unchanged even when probability-level causal metrics move; "
+        "deterministic generation changes only after an argmax boundary is crossed._"
     )
 
 
@@ -127,7 +243,10 @@ def _dose_metrics_markdown(result) -> str:
         f"Feature activation at baseline: **{result.feature_activation:.4f}** · "
         f"target continuation: {len(result.target_tokens)} token(s): {tokens}.{inactive}  \n\n"
         "This panel is **always a scale intervention**: 0× = ablation, 1× = no edit, "
-        "2× = double the original coefficient. It does not use the intervention radio above."
+        "2× = double the native coefficient. All rows are compared with the **1× row from the same batched "
+        "execution context**, so 1× is the numerical null reference.  \n"
+        f"Single-forward → batched-null execution drift: mean log p/token "
+        f"**{result.execution_drift_mean_logprob:+.2e}**, JS **{result.execution_drift_js:.2e}**."
     )
 
 
@@ -135,8 +254,7 @@ def _feature_set_metrics_markdown(result) -> str:
     tokens = " ".join(repr(token) for token in result.target_tokens)
     inactive_count = sum(abs(float(row[1])) < 1e-12 for row in result.feature_rows)
     inactive_note = (
-        f"  \n{inactive_count} selected feature(s) were inactive and therefore contributed zero "
-        "delta under ablation/scale."
+        f"  \n{inactive_count} selected feature(s) were inactive and contributed zero delta."
         if inactive_count
         else ""
     )
@@ -145,25 +263,58 @@ def _feature_set_metrics_markdown(result) -> str:
         f"perturbation L2: **{result.perturbation_norm:.4f}**  \n"
         f"Target continuation: {len(result.target_tokens)} token(s): {tokens}  \n"
         f"SAE Δ mean log p/token: **{result.mean_logprob_delta:+.4f}** · "
-        f"random Δ: **{result.random_mean_logprob_delta:+.4f}** · "
-        f"specificity: **{result.target_specificity_ratio:.2f}×**  \n"
+        f"random ensemble ({result.random_control_count}) mean |Δ|: "
+        f"**{result.random_abs_mean_logprob_delta:.4f}** ± **{result.random_mean_logprob_std:.4f}** · ratio: **{result.target_specificity_ratio:.2f}×** · "
+        f"empirical tail p: **{result.target_empirical_p:.3f}**  \n"
         f"SAE Δ sequence log p: **{result.sequence_logprob_delta:+.4f}** · "
-        f"random Δ: **{result.random_sequence_logprob_delta:+.4f}**  \n"
-        f"Next-token JS: **{result.js_divergence:.6f}** · "
-        f"random-control JS: **{result.random_js_divergence:.6f}** · "
-        f"JS specificity: **{result.js_specificity_ratio:.2f}×**{inactive_note}"
+        f"random signed mean Δ: **{result.random_sequence_logprob_delta:+.4f}**  \n"
+        f"Next-token JS: **{result.js_divergence:.6f}** · random mean JS: "
+        f"**{result.random_js_divergence:.6f}** ± **{result.random_js_std:.6f}** · "
+        f"ratio: **{result.js_specificity_ratio:.2f}×** · empirical tail p: **{result.js_empirical_p:.3f}**  \n"
+        f"Execution-context null drift: mean log p/token **{result.execution_drift_mean_logprob:+.2e}**, "
+        f"JS **{result.execution_drift_js:.2e}**{inactive_note}"
+    )
+
+
+def _interaction_metrics_markdown(result) -> str:
+    tokens = " ".join(repr(token) for token in result.target_tokens)
+    return (
+        f"Target continuation: {len(result.target_tokens)} token(s): {tokens}  \n"
+        f"Additive expectation (sum of individual Δ mean log p/token): "
+        f"**{result.additive_expected_mean_delta:+.4f}**  \n"
+        f"Observed joint Δ mean log p/token: **{result.joint_mean_delta:+.4f}**  \n"
+        f"Interaction excess (joint − additive): **{result.interaction_excess_mean_delta:+.4f}** · "
+        f"normalized: **{result.normalized_interaction:+.3f}**  \n"
+        f"Execution-context null drift: **{result.execution_drift_mean_logprob:+.2e}** mean log p/token.  \n\n"
+        "A non-zero excess indicates **non-additive downstream response under these edits**; it is not, by itself, "
+        "proof that the SAE features form a direct mechanistic circuit."
     )
 
 
 def _paraphrase_metrics_markdown(result) -> str:
     return (
         "#### Robustness metrics\n"
-        f"Full TopK feature-set Jaccard: **{result.topk_jaccard:.3f}**  \n"
-        f"Sparse activation cosine: **{result.sparse_cosine:.3f}**  \n"
-        f"Shared features among displayed top-{result.top_n}: "
-        f"**{result.shared_top_n}/{result.top_n}**  \n\n"
-        "Higher values mean the sparse representation is more stable under the supplied paraphrase; "
-        "they do **not** prove the shared features have identical semantics."
+        "**Selected-token comparison**  \n"
+        f"TopK feature-set Jaccard: **{result.topk_jaccard:.3f}** · "
+        f"sparse activation cosine: **{result.sparse_cosine:.3f}**  \n"
+        f"Shared features among displayed top-{result.top_n}: **{result.shared_top_n}/{result.top_n}**  \n\n"
+        "**Prompt-wide comparison** — max activation of each feature across all prompt tokens  \n"
+        f"Feature-set Jaccard: **{result.promptwide_jaccard:.3f}** · "
+        f"activation cosine: **{result.promptwide_cosine:.3f}**  \n\n"
+        "The prompt-wide view reduces sensitivity to choosing semantically different final tokens, while the "
+        "selected-token view remains the stricter local representation test. Neither metric establishes feature semantics."
+    )
+
+
+def _concept_metrics_markdown(result) -> str:
+    ratio_text = "undefined" if result.leading_ratio == 0 else f"{result.leading_ratio:.2f}×"
+    return (
+        f"Feature **{result.feature_id}**, layer **{result.layer}** · "
+        f"{result.prompts_per_concept} controlled prompts/concept.  \n"
+        f"Highest mean activation in this small live contrast: **{result.leading_concept}** "
+        f"({ratio_text} the runner-up mean).  \n\n"
+        "This is an **exploratory contrast scan**, not an automatic semantic label. The offline held-out AUROC/F1 "
+        "benchmark remains the stronger feature/concept evidence."
     )
 
 
@@ -173,12 +324,12 @@ def analyze_prompt(prompt: str, layer: int, token_index: int, top_n: int):
         if not prompt.strip():
             raise ValueError("Enter a prompt first.")
         result = RUNTIME.analyze(prompt, int(layer), int(token_index), int(top_n))
+        columns = ["Rank", "Feature id", "Activation", "Offline concept hint"]
+        table = pd.DataFrame(result.rows, columns=columns)
         choices = [str(int(row[1])) for row in result.rows]
         feature_update = gr.update(choices=choices, value=choices[0] if choices else None)
-        feature_set_update = gr.update(
-            choices=choices,
-            value=choices[: min(3, len(choices))],
-        )
+        feature_set_update = gr.update(choices=choices, value=choices[: min(3, len(choices))])
+        contrast_update = gr.update(choices=choices, value=choices[0] if choices else None)
         chart_df = pd.DataFrame(
             {
                 "Feature": [str(int(row[1])) for row in result.rows],
@@ -186,13 +337,22 @@ def analyze_prompt(prompt: str, layer: int, token_index: int, top_n: int):
                 "Series": ["Activation"] * len(result.rows),
             }
         )
+        location = (
+            f"Current Workbench location — **layer {int(layer)}**, **prompt token {result.token_index}**; "
+            f"prompt: `{prompt[:90]}{'…' if len(prompt) > 90 else ''}`"
+        )
         return (
             RUNTIME.token_html(result.tokens, result.token_index),
-            result.rows,
+            table,
             chart_df,
             feature_update,
             feature_set_update,
+            contrast_update,
+            gr.update(value=int(layer)),
             _analysis_metrics_markdown(result),
+            location,
+            location,
+            _tsv(table),
         )
     except Exception as exc:
         _raise_ui_error(exc)
@@ -214,36 +374,43 @@ def run_intervention(
             raise ValueError("Enter a prompt first.")
         if feature_id is None or str(feature_id).strip() == "":
             raise ValueError("Choose or enter a feature id.")
-        fid = int(float(feature_id))
         result = RUNTIME.intervene(
             text=prompt,
             layer=int(layer),
             token_index=int(token_index),
-            feature_id=fid,
+            feature_id=int(float(feature_id)),
             mode=mode,
             coefficient=float(coefficient),
             target_text=target_text,
             max_new_tokens=int(max_new_tokens),
         )
+        token_columns = ["Token", "Baseline p", "SAE-edit p", "Δ probability"]
+        target_columns = [
+            "Target position",
+            "Target token",
+            "Baseline log p",
+            "SAE-edit log p",
+            "Random-ensemble mean log p",
+            "SAE Δ log p",
+            "Random-ensemble mean Δ log p",
+        ]
+        token_df = pd.DataFrame(result.top_token_rows, columns=token_columns)
+        target_df = pd.DataFrame(result.target_token_rows, columns=target_columns)
         return (
             result.baseline_text,
             result.modified_text,
             _intervention_metrics_markdown(result),
-            result.top_token_rows,
-            result.target_token_rows,
+            token_df,
+            target_df,
+            _tsv(token_df),
+            _tsv(target_df),
         )
     except Exception as exc:
         _raise_ui_error(exc)
 
 
 @gpu(duration=35)
-def run_dose_response(
-    prompt: str,
-    layer: int,
-    token_index: int,
-    feature_id: str,
-    target_text: str,
-):
+def run_dose_response(prompt: str, layer: int, token_index: int, feature_id: str, target_text: str):
     try:
         if not prompt.strip():
             raise ValueError("Enter a prompt first.")
@@ -262,7 +429,7 @@ def run_dose_response(
             "Multiplier",
             "Δ feature coefficient",
             "Perturbation L2",
-            "Baseline mean log p/token",
+            "Batched-null mean log p/token",
             "Modified mean log p/token",
             "Δ mean log p/token",
             "Δ sequence log p",
@@ -271,7 +438,7 @@ def run_dose_response(
         table = pd.DataFrame(result.rows, columns=columns)
         plot = table[["Multiplier", "Δ mean log p/token"]].copy()
         plot["Series"] = "SAE feature"
-        return table, plot, _dose_metrics_markdown(result)
+        return table, plot, _dose_metrics_markdown(result), _tsv(table)
     except Exception as exc:
         _raise_ui_error(exc)
 
@@ -298,12 +465,12 @@ def run_layer_sweep(prompt: str, token_index: int):
             var_name="Metric",
             value_name="Value",
         )
-        return RUNTIME.token_html(result.tokens, result.token_index), table, long
+        return RUNTIME.token_html(result.tokens, result.token_index), table, long, _tsv(table)
     except Exception as exc:
         _raise_ui_error(exc)
 
 
-@gpu(duration=35)
+@gpu(duration=40)
 def run_feature_set(
     prompt: str,
     layer: int,
@@ -315,7 +482,7 @@ def run_feature_set(
 ):
     try:
         if not prompt.strip():
-            raise ValueError("Enter a prompt in the Workbench first.")
+            raise ValueError("Enter and inspect a prompt in the Workbench first.")
         selected = [int(float(value)) for value in (feature_ids or [])]
         if not selected:
             raise ValueError("Select at least one feature in 'Feature set'.")
@@ -330,21 +497,34 @@ def run_feature_set(
             coefficient=float(coefficient),
             target_text=target_text,
         )
-        return result.feature_rows, _feature_set_metrics_markdown(result), result.target_token_rows
+        feature_columns = ["Feature id", "Original activation", "Δ coefficient", "Offline concept hint"]
+        target_columns = [
+            "Target position",
+            "Target token",
+            "Baseline log p",
+            "SAE-edit log p",
+            "Random-ensemble mean log p",
+            "SAE Δ log p",
+            "Random-ensemble mean Δ log p",
+        ]
+        feature_df = pd.DataFrame(result.feature_rows, columns=feature_columns)
+        target_df = pd.DataFrame(result.target_token_rows, columns=target_columns)
+        return (
+            feature_df,
+            _feature_set_metrics_markdown(result),
+            target_df,
+            _tsv(feature_df),
+            _tsv(target_df),
+        )
     except Exception as exc:
         _raise_ui_error(exc)
 
 
-@gpu(duration=35)
-def run_feature_set_sweep(
-    prompt: str,
-    layer: int,
-    token_index: int,
-    target_text: str,
-):
+@gpu(duration=45)
+def run_feature_set_sweep(prompt: str, layer: int, token_index: int, target_text: str):
     try:
         if not prompt.strip():
-            raise ValueError("Enter a prompt in the Workbench first.")
+            raise ValueError("Enter and inspect a prompt in the Workbench first.")
         if not target_text.strip():
             raise ValueError("Enter a target continuation before running the set-size sweep.")
         result = RUNTIME.feature_set_size_sweep(
@@ -357,28 +537,78 @@ def run_feature_set_sweep(
             "Set size k",
             "Feature ids",
             "Perturbation L2",
-            "Baseline mean log p/token",
+            "Batched-null mean log p/token",
             "SAE mean log p/token",
             "SAE Δ mean log p/token",
-            "Random Δ mean log p/token",
-            "Specificity ratio",
+            "Random signed mean Δ",
+            "Random mean |Δ|",
+            "Random |Δ| std",
+            "SAE/random magnitude ratio",
+            "Empirical tail p",
             "SAE Δ sequence log p",
             "SAE next-token JS",
-            "Random next-token JS",
+            "Random mean JS",
+            "Random JS std",
+            "JS empirical tail p",
         ]
         table = pd.DataFrame(result.rows, columns=columns)
-        plot_rows = []
+        plot_rows: list[list[object]] = []
         for _, row in table.iterrows():
             plot_rows.append([row["Set size k"], "Top-k SAE ablation", row["SAE Δ mean log p/token"]])
-            plot_rows.append([row["Set size k"], "Norm-matched random", row["Random Δ mean log p/token"]])
+            plot_rows.append([row["Set size k"], "Random signed mean", row["Random signed mean Δ"]])
         plot = pd.DataFrame(plot_rows, columns=["Set size k", "Condition", "Δ mean log p/token"])
         tokens = " ".join(repr(token) for token in result.target_tokens)
         note = (
-            f"Target continuation: {len(result.target_tokens)} token(s): {tokens}. "
-            "For each k, FeatureLens jointly **ablates the k strongest active SAE features** at the "
-            "selected prompt token and compares that joint edit with a norm-matched random residual control."
+            f"Target continuation: {len(result.target_tokens)} token(s): {tokens}. For each k, FeatureLens "
+            f"ablates the k strongest active features and compares the effect with **{result.random_control_count} "
+            f"norm-matched random directions**. All conditions share one batched zero-edit reference.  \n"
+            f"Execution-context null drift: mean log p/token **{result.execution_drift_mean_logprob:+.2e}**, "
+            f"JS **{result.execution_drift_js:.2e}**. The live empirical p-value is intentionally coarse because "
+            f"it uses only {result.random_control_count} controls; the offline experiment should use more."
         )
-        return table, plot, note
+        return table, plot, note, _tsv(table)
+    except Exception as exc:
+        _raise_ui_error(exc)
+
+
+@gpu(duration=40)
+def run_feature_interaction(
+    prompt: str,
+    layer: int,
+    token_index: int,
+    feature_ids: list[str] | None,
+    target_text: str,
+):
+    try:
+        selected = [int(float(value)) for value in (feature_ids or [])]
+        if not prompt.strip():
+            raise ValueError("Enter and inspect a prompt in the Workbench first.")
+        if len(selected) < 2:
+            raise ValueError("Select at least two features in 'Feature set'.")
+        if len(selected) > 5:
+            raise ValueError("Select at most five features for the interaction decomposition.")
+        if not target_text.strip():
+            raise ValueError("Enter a target continuation for the interaction decomposition.")
+        result = RUNTIME.feature_interaction_test(
+            text=prompt,
+            layer=int(layer),
+            token_index=int(token_index),
+            feature_ids=selected,
+            target_text=target_text,
+        )
+        columns = [
+            "Condition",
+            "Feature ids",
+            "Activation summary",
+            "Perturbation L2",
+            "Δ mean log p/token",
+            "Δ sequence log p",
+            "Next-token JS",
+        ]
+        table = pd.DataFrame(result.rows, columns=columns)
+        plot = table[["Condition", "Δ mean log p/token"]].copy()
+        plot["Series"] = "Ablation effect"
+        return table, _interaction_metrics_markdown(result), plot, _tsv(table)
     except Exception as exc:
         _raise_ui_error(exc)
 
@@ -401,72 +631,75 @@ def run_paraphrase_compare(
             token_index_b=int(token_index_b),
             top_n=int(top_n),
         )
+        columns = ["Feature id", "Original activation", "Paraphrase activation", "Status", "Offline concept hint"]
+        table = pd.DataFrame(result.rows, columns=columns)
         chart = pd.DataFrame(result.chart_rows, columns=["Feature", "Prompt", "Activation"])
         return (
             RUNTIME.token_html(result.tokens_a, result.token_index_a),
             RUNTIME.token_html(result.tokens_b, result.token_index_b),
             _paraphrase_metrics_markdown(result),
-            result.rows,
+            table,
             chart,
+            _tsv(table),
+        )
+    except Exception as exc:
+        _raise_ui_error(exc)
+
+
+@gpu(duration=35)
+def run_concept_contrast(feature_id: str, layer: int, prompts_per_concept: int):
+    try:
+        if feature_id is None or str(feature_id).strip() == "":
+            raise ValueError("Choose a feature id first. Run Workbench inspection if the selector is empty.")
+        result = RUNTIME.concept_contrast_scan(
+            feature_id=int(float(feature_id)),
+            layer=int(layer),
+            prompts_per_concept=int(prompts_per_concept),
         )
+        columns = [
+            "Concept",
+            "Prompts",
+            "Mean activation",
+            "Median activation",
+            "Activation rate",
+            "Max activation",
+        ]
+        table = pd.DataFrame(result.rows, columns=columns)
+        chart = pd.DataFrame(result.chart_rows, columns=["Concept", "Mean activation"])
+        chart["Series"] = "Mean activation"
+        return _concept_metrics_markdown(result), table, chart, _tsv(table)
     except Exception as exc:
         _raise_ui_error(exc)
 
 
 def mode_help(mode: str):
     if mode == "ablate":
-        return gr.update(
-            value=0.0,
-            interactive=False,
-            label="Coefficient (unused for ablation)",
-            info="Sets the selected active feature coefficient to zero.",
-        )
+        return gr.update(value=0.0, interactive=False, label="Coefficient (unused for ablation)")
     if mode == "scale":
-        return gr.update(
-            value=2.0,
-            interactive=True,
-            label="Feature multiplier",
-            info="1 = unchanged, 0 = ablate, 2 = double the original coefficient.",
-        )
-    return gr.update(
-        value=5.0,
-        interactive=True,
-        label="Additive feature coefficient",
-        info="Adds this amount along the decoder direction, even when the feature is inactive.",
-    )
+        return gr.update(value=2.0, interactive=True, label="Feature multiplier")
+    return gr.update(value=5.0, interactive=True, label="Additive feature coefficient")
 
 
 def set_mode_help(mode: str):
     if mode == "ablate":
-        return gr.update(
-            value=0.0,
-            interactive=False,
-            label="Set coefficient (unused for ablation)",
-            info="Jointly sets every selected active feature coefficient to zero.",
-        )
-    return gr.update(
-        value=2.0,
-        interactive=True,
-        label="Shared feature multiplier",
-        info="Applies the same multiplier to each selected feature before summing decoder deltas.",
-    )
+        return gr.update(value=0.0, interactive=False, label="Multiplier (unused for ablation)")
+    return gr.update(value=2.0, interactive=True, label="Shared feature multiplier")
 
 
 with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench") as demo:
     gr.HTML(
-        '<div class="hero"><h1>FeatureLens <span style="font-size:.42em;opacity:.55">v0.3</span></h1>'
-        '<p>Causal sparse-feature interpretability for Qwen3-1.7B — inspect → intervene → control → measure.</p></div>'
-        '<div class="research-q"><b>Research question:</b> Do sparse features that predict a concept also '
-        'causally influence the model’s behaviour?</div>'
-        '<div class="badges">'
-        '<span class="badge">Qwen3-1.7B-Base</span><span class="badge">Qwen-Scope SAE</span>'
-        '<span class="badge">32,768 features</span><span class="badge">TopK=50</span>'
-        '<span class="badge">full-sequence scoring</span><span class="badge">feature sets</span>'
-        '<span class="badge">norm-matched controls</span><span class="badge">ZeroGPU</span></div>'
+        '<header class="hero">'
+        '<h1>FeatureLens <span style="font-size:.48em;opacity:.58;font-weight:400">v0.4</span></h1>'
+        '<div class="subtitle">Causal Interpretability Workbench</div>'
+        '<div class="metadata">Qwen3-1.7B-Base · Qwen-Scope residual SAEs · layers 4 / 14 / 26 · '
+        '32,768 features · TopK=50 · ZeroGPU</div>'
+        '</header>'
+        '<div class="research-q"><strong>Research question.</strong> Do sparse features that predict a concept '
+        'also causally influence the model’s behaviour?</div>'
     )
 
     with gr.Tab("Workbench"):
-        gr.HTML('<div class="step">Step 1 · Inspect one prompt location</div>')
+        gr.HTML('<div class="section-rule">I. Inspect a prompt location</div>')
         with gr.Row(equal_height=False):
             with gr.Column(scale=5):
                 prompt = gr.Textbox(
@@ -490,47 +723,50 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench") as dem
                     choices=list(SETTINGS.layers),
                     value=SETTINGS.layers[1] if len(SETTINGS.layers) > 1 else SETTINGS.layers[0],
                     label="Residual layer",
-                    info="Early / middle / late checkpoints are intentionally sampled.",
                 )
                 token_index = gr.Number(
                     value=-1,
                     precision=0,
                     label="Prompt token index",
-                    info="-1 = final prompt token. Inspect once to see all token positions below.",
+                    info="-1 = final prompt token.",
                 )
                 top_n = gr.Slider(5, 20, value=12, step=1, label="Displayed active features")
                 analyze_btn = gr.Button("Inspect sparse features", variant="primary")
 
         gr.Markdown("#### Prompt tokens\nThe selected prompt token is outlined more strongly.")
-        token_view = gr.HTML('<div class="small-note">Prompt tokens appear here after clicking <b>Inspect sparse features</b>.</div>')
+        token_view = gr.HTML(
+            '<div class="small-note">Prompt tokens appear here after clicking <b>Inspect sparse features</b>.</div>'
+        )
         analysis_metrics = gr.Markdown()
         with gr.Row(equal_height=False):
-            feature_table = gr.Dataframe(
-                headers=["Rank", "Feature id", "Activation", "Offline concept hint"],
-                datatype=["number", "number", "number", "str"],
-                interactive=False,
-                label="Strongest active SAE features",
-                wrap=True,
-                scale=3,
-            )
-            feature_plot = gr.BarPlot(
-                x="Feature",
-                y="Activation",
-                color="Series",
-                color_map={"Activation": MUTED_TEAL},
-                title="Activation profile",
-                x_title="Feature id",
-                y_title="Activation",
-                x_label_angle=-35,
-                height=330,
-                scale=2,
-            )
+            with gr.Column(scale=3):
+                feature_table = gr.Dataframe(
+                    headers=["Rank", "Feature id", "Activation", "Offline concept hint"],
+                    datatype=["number", "number", "number", "str"],
+                    interactive=False,
+                    label="Strongest active SAE features",
+                    wrap=True,
+                    buttons=["fullscreen"],
+                )
+                feature_tsv = gr.Textbox(visible="hidden")
+                feature_copy = _copy_button()
+            with gr.Column(scale=2):
+                feature_plot = gr.BarPlot(
+                    x="Feature",
+                    y="Activation",
+                    color="Series",
+                    color_map={"Activation": INK_TEAL},
+                    title="Activation profile",
+                    x_title="Feature id",
+                    y_title="Activation",
+                    x_label_angle=-35,
+                    height=330,
+                )
 
-        gr.HTML('<div class="step">Step 2 · Run one single-feature causal test</div>')
+        gr.HTML('<div class="section-rule">II. Single-feature causal test</div>')
         gr.Markdown(
-            "FeatureLens edits the **original residual**, then compares the SAE edit with a deterministic "
-            "random residual perturbation of the **same L2 norm**. If a target continuation is supplied, "
-            "v0.3 scores the **entire continuation teacher-forced**, not only its first token."
+            "The edit is compared with an **8-direction norm-matched random ensemble** in the same batched "
+            "execution context. If a target continuation is supplied, the complete continuation is scored teacher-forced."
         )
         with gr.Row(equal_height=False):
             with gr.Column(scale=2):
@@ -538,9 +774,8 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench") as dem
                     choices=[],
                     allow_custom_value=True,
                     label="Single feature id",
-                    info="Inspection populates the strongest active features; custom IDs are also allowed.",
                 )
-                mode = gr.Radio(
+                mode = gr.Dropdown(
                     choices=["ablate", "scale", "inject"],
                     value="ablate",
                     label="Single-feature intervention",
@@ -553,10 +788,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench") as dem
                 target_text = gr.Textbox(
                     label="Target continuation (optional)",
                     placeholder="e.g. 2x",
-                    info=(
-                        "Exact text to score after the prompt. v0.3 reports full-sequence and per-token "
-                        "log probabilities. Include a leading space if that is part of the continuation."
-                    ),
+                    info="Exact text appended to the prompt for teacher-forced scoring.",
                 )
                 max_new = gr.Slider(
                     4,
@@ -572,55 +804,60 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench") as dem
                     baseline_out = gr.Textbox(label="Baseline greedy generation", lines=6, interactive=False)
                     modified_out = gr.Textbox(label="SAE-edited greedy generation", lines=6, interactive=False)
                 token_prob_table = gr.Dataframe(
-                    headers=["Token", "Baseline p", "SAE-edit p", "Δ probability"],
-                    datatype=["str", "number", "number", "number"],
                     interactive=False,
                     label="Next-token distribution shift",
+                    buttons=["fullscreen"],
+                    wrap=True,
                 )
+                token_prob_tsv = gr.Textbox(visible="hidden")
+                token_prob_copy = _copy_button()
                 target_token_table = gr.Dataframe(
-                    headers=[
-                        "Target position",
-                        "Target token",
-                        "Baseline log p",
-                        "SAE-edit log p",
-                        "Random log p",
-                        "SAE Δ log p",
-                        "Random Δ log p",
-                    ],
-                    datatype=["number", "str", "number", "number", "number", "number", "number"],
                     interactive=False,
                     label="Target continuation token-by-token score",
+                    buttons=["fullscreen"],
+                    wrap=True,
                 )
+                target_token_tsv = gr.Textbox(visible="hidden")
+                target_token_copy = _copy_button()
 
-        gr.HTML('<div class="step">Step 3 · Check single-feature dose-response</div>')
-        with gr.Accordion("Single-feature scale dose-response", open=False):
+        gr.HTML('<div class="section-rule">III. Single-feature scale dose-response</div>')
+        with gr.Accordion("Scale dose-response", open=False):
             gr.Markdown(
-                "This panel is **always a scale intervention**, regardless of the radio choice above. "
-                "It evaluates **0×, 0.5×, 1×, 1.5×, 2× and 3×** in one batched forward pass after the "
-                "baseline. Here **0× = ablation** and **1× = no intervention**."
+                "Always a **scale** experiment: 0× = ablation, 1× = numerical no-edit reference, 2× = double "
+                "the native coefficient. The six conditions are evaluated together, and all deltas are measured "
+                "against the 1× row from that same batch."
             )
             dose_btn = gr.Button("Run scale dose-response")
             dose_metrics = gr.Markdown()
-            with gr.Row():
-                dose_table = gr.Dataframe(interactive=False, label="Scale dose-response measurements", scale=3)
-                dose_plot = gr.LinePlot(
-                    x="Multiplier",
-                    y="Δ mean log p/token",
-                    color="Series",
-                    color_map={"SAE feature": MUTED_TEAL},
-                    title="Scale dose-response",
-                    x_title="Feature multiplier",
-                    y_title="Δ mean log p/token",
-                    height=330,
-                    scale=2,
-                )
+            with gr.Row(equal_height=False):
+                with gr.Column(scale=3):
+                    dose_table = gr.Dataframe(
+                        interactive=False,
+                        label="Scale dose-response measurements",
+                        buttons=["fullscreen"],
+                        wrap=True,
+                    )
+                    dose_tsv = gr.Textbox(visible="hidden")
+                    dose_copy = _copy_button()
+                with gr.Column(scale=2):
+                    dose_plot = gr.LinePlot(
+                        x="Multiplier",
+                        y="Δ mean log p/token",
+                        color="Series",
+                        color_map={"SAE feature": INK_TEAL},
+                        title="Scale dose-response",
+                        x_title="Feature multiplier",
+                        y_title="Δ mean log p/token",
+                        height=330,
+                    )
 
     with gr.Tab("Feature sets"):
         gr.Markdown(
-            "### Test distributed sparse representations\n"
-            "This tab reuses the **Prompt**, **Residual layer**, and **Prompt token index** from the Workbench. "
-            "Click **Inspect sparse features** there first; its displayed feature IDs populate the selector below."
+            "### Distributed sparse representations\n"
+            "Run **Inspect sparse features** in the Workbench first. The prompt, layer, token index, and active "
+            "feature selector below reuse that Workbench state."
         )
+        feature_set_location = gr.Markdown("No Workbench inspection has been run yet.")
         feature_set_ids = gr.Dropdown(
             choices=[],
             value=[],
@@ -628,86 +865,180 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench") as dem
             allow_custom_value=True,
             max_choices=12,
             label="Feature set",
-            info="Choose several active features from the Workbench inspection, or enter custom IDs.",
         )
-        with gr.Row():
-            set_mode = gr.Radio(
+
+        gr.Markdown("#### Joint feature-set causal test")
+        gr.HTML(
+            '<div class="instrument-note">Ablation ignores the multiplier. Scale applies one shared multiplier '
+            'to every selected feature before decoder deltas are summed. Additive injection is deliberately omitted '
+            'because one coefficient is not comparable across unrelated directions.</div>'
+        )
+        with gr.Row(equal_height=True):
+            set_mode = gr.Dropdown(
                 choices=["ablate", "scale"],
                 value="ablate",
-                label="Feature-set intervention",
-                info="Inject is omitted because one shared additive coefficient is not comparable across multiple directions.",
+                label="Intervention",
+                scale=1,
             )
             set_coefficient = gr.Number(
                 value=0.0,
                 interactive=False,
-                label="Set coefficient (unused for ablation)",
+                label="Multiplier (unused for ablation)",
+                scale=1,
             )
             set_target = gr.Textbox(
                 label="Target continuation",
                 value="2x",
-                info="Required. The complete continuation is scored teacher-forced.",
+                lines=1,
+                scale=2,
             )
         set_btn = gr.Button("Run joint feature-set causal test", variant="primary")
         set_metrics = gr.Markdown()
-        with gr.Row():
-            set_feature_table = gr.Dataframe(
-                headers=["Feature id", "Original activation", "Δ coefficient", "Offline concept hint"],
-                datatype=["number", "number", "number", "str"],
-                interactive=False,
-                label="Joint intervention features",
-                scale=2,
-            )
-            set_target_table = gr.Dataframe(
-                headers=[
-                    "Target position",
-                    "Target token",
-                    "Baseline log p",
-                    "SAE-edit log p",
-                    "Random log p",
-                    "SAE Δ log p",
-                    "Random Δ log p",
-                ],
-                datatype=["number", "str", "number", "number", "number", "number", "number"],
-                interactive=False,
-                label="Target continuation token-by-token score",
-                scale=3,
-            )
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=2):
+                set_feature_table = gr.Dataframe(
+                    interactive=False,
+                    label="Joint intervention features",
+                    buttons=["fullscreen"],
+                    wrap=True,
+                )
+                set_feature_tsv = gr.Textbox(visible="hidden")
+                set_feature_copy = _copy_button()
+            with gr.Column(scale=3):
+                set_target_table = gr.Dataframe(
+                    interactive=False,
+                    label="Target continuation token-by-token score",
+                    buttons=["fullscreen"],
+                    wrap=True,
+                )
+                set_target_tsv = gr.Textbox(visible="hidden")
+                set_target_copy = _copy_button()
 
-        gr.Markdown("### Top-k joint-ablation sweep")
+        gr.HTML('<div class="section-rule">Set-size sensitivity</div>')
         gr.Markdown(
-            "Instead of choosing a single feature, this experiment automatically ablates the **1, 3, and 5 "
-            "strongest active features** at the current Workbench location. All six edited/control conditions "
-            "are evaluated in one batched forward pass after the baseline."
-        )
-        set_sweep_target = gr.Textbox(
-            label="Target continuation for set-size sweep",
-            value="2x",
+            "Ablates the **1, 3, and 5 strongest active features**. Each targeted edit is compared with eight "
+            "norm-matched random directions, all sharing one batched no-edit baseline."
         )
+        set_sweep_target = gr.Textbox(label="Target continuation for set-size sweep", value="2x")
         set_sweep_btn = gr.Button("Run 1/3/5-feature ablation sweep")
         set_sweep_note = gr.Markdown()
-        with gr.Row():
-            set_sweep_table = gr.Dataframe(interactive=False, label="Feature-set size measurements", scale=3)
-            set_sweep_plot = gr.LinePlot(
-                x="Set size k",
-                y="Δ mean log p/token",
-                color="Condition",
-                color_map={
-                    "Top-k SAE ablation": MUTED_TEAL,
-                    "Norm-matched random": MUTED_STONE,
-                },
-                title="Effect vs feature-set size",
-                x_title="Number of jointly ablated features",
-                y_title="Δ mean log p/token",
-                height=330,
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=3):
+                set_sweep_table = gr.Dataframe(
+                    interactive=False,
+                    label="Feature-set size measurements",
+                    buttons=["fullscreen"],
+                    wrap=True,
+                )
+                set_sweep_tsv = gr.Textbox(visible="hidden")
+                set_sweep_copy = _copy_button()
+            with gr.Column(scale=2):
+                set_sweep_plot = gr.LinePlot(
+                    x="Set size k",
+                    y="Δ mean log p/token",
+                    color="Condition",
+                    color_map={
+                        "Top-k SAE ablation": INK_TEAL,
+                        "Random signed mean": INK_STONE,
+                    },
+                    title="Effect vs feature-set size",
+                    x_title="Number of jointly ablated features",
+                    y_title="Δ mean log p/token",
+                    height=330,
+                )
+
+        gr.HTML('<div class="section-rule">Non-additivity / interaction decomposition</div>')
+        gr.Markdown(
+            "For the selected 2–5 features, FeatureLens batches each **individual ablation** plus the **joint "
+            "ablation**. It compares the observed joint effect with the sum of individual effects. This diagnoses "
+            "non-additivity without claiming that the features form a direct circuit."
+        )
+        interaction_target = gr.Textbox(label="Target continuation for interaction test", value="2x")
+        interaction_btn = gr.Button("Run individual-vs-joint decomposition")
+        interaction_metrics = gr.Markdown()
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=3):
+                interaction_table = gr.Dataframe(
+                    interactive=False,
+                    label="Individual and joint ablation measurements",
+                    buttons=["fullscreen"],
+                    wrap=True,
+                )
+                interaction_tsv = gr.Textbox(visible="hidden")
+                interaction_copy = _copy_button()
+            with gr.Column(scale=2):
+                interaction_plot = gr.BarPlot(
+                    x="Condition",
+                    y="Δ mean log p/token",
+                    color="Series",
+                    color_map={"Ablation effect": INK_UMBER},
+                    title="Individual vs joint effect",
+                    x_title="Intervention condition",
+                    y_title="Δ mean log p/token",
+                    x_label_angle=-25,
+                    height=330,
+                )
+
+    with gr.Tab("Feature evidence"):
+        gr.Markdown(
+            "### Controlled concept contrast scan\n"
+            "This lightweight live test asks whether the selected SAE feature activates preferentially on one of "
+            "FeatureLens's seven controlled concept groups. It uses one wording per paraphrase pair and evaluates "
+            "the **final prompt token** for every contrast prompt in one batch."
+        )
+        contrast_location = gr.Markdown("No Workbench inspection has been run yet.")
+        with gr.Row(equal_height=True):
+            contrast_feature_id = gr.Dropdown(
+                choices=[],
+                allow_custom_value=True,
+                label="Feature id",
+                scale=2,
+            )
+            contrast_layer = gr.Dropdown(
+                choices=list(SETTINGS.layers),
+                value=SETTINGS.layers[1],
+                label="Residual layer",
+                scale=1,
+            )
+            contrast_n = gr.Slider(
+                2,
+                6,
+                value=SETTINGS.contrast_prompts_per_concept,
+                step=1,
+                label="Prompts per concept",
                 scale=2,
             )
+        contrast_btn = gr.Button("Run controlled concept contrast", variant="primary")
+        contrast_metrics = gr.Markdown()
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=3):
+                contrast_table = gr.Dataframe(
+                    interactive=False,
+                    label="Feature activation by controlled concept",
+                    buttons=["fullscreen"],
+                    wrap=True,
+                )
+                contrast_tsv = gr.Textbox(visible="hidden")
+                contrast_copy = _copy_button()
+            with gr.Column(scale=2):
+                contrast_plot = gr.BarPlot(
+                    x="Concept",
+                    y="Mean activation",
+                    color="Series",
+                    color_map={"Mean activation": INK_BLUEGREY},
+                    title="Controlled concept contrast",
+                    x_title="Concept",
+                    y_title="Mean feature activation",
+                    x_label_angle=-25,
+                    height=330,
+                )
 
     with gr.Tab("Paraphrase robustness"):
         gr.Markdown(
-            "### Does the sparse representation survive a rewording?\n"
-            "Compare the TopK SAE representation of an original prompt with a manually supplied paraphrase. "
-            "This mirrors the offline paraphrase-stability evaluation without pretending that feature IDs "
-            "have known semantics."
+            "### Local and prompt-wide robustness\n"
+            "The selected-token comparison is strict but can be misleading if the two chosen tokens play different "
+            "semantic roles. v0.4 therefore also reports a **prompt-wide max-pooled feature profile**: for every SAE "
+            "feature, take its maximum activation across all prompt tokens, then compare the two sparse profiles."
         )
         with gr.Row():
             para_a = gr.Textbox(
@@ -723,7 +1054,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench") as dem
         with gr.Row():
             para_layer = gr.Dropdown(
                 choices=list(SETTINGS.layers),
-                value=SETTINGS.layers[1] if len(SETTINGS.layers) > 1 else SETTINGS.layers[0],
+                value=SETTINGS.layers[1],
                 label="Residual layer",
             )
             para_idx_a = gr.Number(value=-1, precision=0, label="Original prompt token index")
@@ -738,33 +1069,33 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench") as dem
                 gr.Markdown("#### Paraphrase tokens")
                 para_tokens_b = gr.HTML()
         para_metrics = gr.Markdown()
-        with gr.Row():
-            para_table = gr.Dataframe(
-                headers=["Feature id", "Original activation", "Paraphrase activation", "Status", "Offline concept hint"],
-                datatype=["number", "number", "number", "str", "str"],
-                interactive=False,
-                label="Top-feature overlap",
-                scale=3,
-            )
-            para_plot = gr.BarPlot(
-                x="Feature",
-                y="Activation",
-                color="Prompt",
-                color_map={"Original": MUTED_TEAL, "Paraphrase": MUTED_PURPLE},
-                title="Original vs paraphrase activation",
-                x_title="Feature id",
-                y_title="Activation",
-                x_label_angle=-35,
-                height=330,
-                scale=2,
-            )
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=3):
+                para_table = gr.Dataframe(
+                    interactive=False,
+                    label="Top-feature overlap at selected tokens",
+                    buttons=["fullscreen"],
+                    wrap=True,
+                )
+                para_tsv = gr.Textbox(visible="hidden")
+                para_copy = _copy_button()
+            with gr.Column(scale=2):
+                para_plot = gr.BarPlot(
+                    x="Feature",
+                    y="Activation",
+                    color="Prompt",
+                    color_map={"Original": INK_TEAL, "Paraphrase": INK_PLUM},
+                    title="Selected-token feature activations",
+                    x_title="Feature id",
+                    y_title="Activation",
+                    x_label_angle=-35,
+                    height=330,
+                )
 
     with gr.Tab("Layer trajectory"):
         gr.Markdown(
-            "### Follow representation structure across early, middle and late residual streams\n"
-            "This is **not** a cross-layer feature-ID comparison — SAE dictionaries are layer-specific. "
-            "It compares reconstruction quality and sparsity/concentration statistics at the same prompt "
-            "token across layers 4, 14 and 26."
+            "### Representation structure across early, middle and late residual streams\n"
+            "This is not a cross-layer feature-ID comparison; the SAE dictionaries are layer-specific."
         )
         with gr.Row():
             trajectory_prompt = gr.Textbox(
@@ -783,32 +1114,39 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench") as dem
         trajectory_btn = gr.Button("Compare layers", variant="primary")
         gr.Markdown("#### Prompt tokens")
         trajectory_tokens = gr.HTML()
-        with gr.Row():
-            trajectory_table = gr.Dataframe(interactive=False, label="Layer diagnostics", scale=3)
-            trajectory_plot = gr.LinePlot(
-                x="Layer",
-                y="Value",
-                color="Metric",
-                color_map={
-                    "Reconstruction cosine": MUTED_TEAL,
-                    "Top-5 mass": MUTED_OCHRE,
-                    "Activation entropy": MUTED_RED,
-                },
-                title="Representation trajectory",
-                x_title="Layer",
-                y_title="Normalized value",
-                height=330,
-                scale=2,
-            )
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=3):
+                trajectory_table = gr.Dataframe(
+                    interactive=False,
+                    label="Layer diagnostics",
+                    buttons=["fullscreen"],
+                    wrap=True,
+                )
+                trajectory_tsv = gr.Textbox(visible="hidden")
+                trajectory_copy = _copy_button()
+            with gr.Column(scale=2):
+                trajectory_plot = gr.LinePlot(
+                    x="Layer",
+                    y="Value",
+                    color="Metric",
+                    color_map={
+                        "Reconstruction cosine": INK_TEAL,
+                        "Top-5 mass": INK_UMBER,
+                        "Activation entropy": INK_RED,
+                    },
+                    title="Representation trajectory",
+                    x_title="Layer",
+                    y_title="Normalized value",
+                    height=330,
+                )
 
     with gr.Tab("Offline benchmark"):
         gr.Markdown(RUNTIME.catalog.benchmark_markdown())
         gr.Markdown(
-            "The offline pipeline evaluates held-out feature/concept AUROC + F1, reconstruction quality, "
-            "paraphrase stability, dense residual linear probes, single-feature causal edits, and v0.3 "
-            "top-k feature-set ablations against norm-matched controls. Target outcomes use **full continuation "
-            "teacher-forced log probability**, with mean log p/token used for length-comparable aggregate tests. "
-            "Results are loaded from `artifacts/`; the app never ships invented benchmark numbers."
+            "The offline pipeline remains the source of held-out feature/concept AUROC + F1, reconstruction "
+            "quality, paraphrase stability, dense residual linear probes, and causal intervention conclusions. "
+            "v0.4 strengthens the live workbench with batch-context null references and random-control ensembles; "
+            "the saved report should be generated only from real experiment artifacts."
         )
 
     with gr.Tab("Method"):
@@ -819,42 +1157,41 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench") as dem
 For residual vector $h$, sparse coefficient $z_i$, decoder direction $d_i$, and scale $\alpha$:
 
 - **Ablate:** $h' = h - z_i d_i$
-- **Scale:** $h' = h + (\alpha - 1) z_i d_i$
+- **Scale:** $h' = h + (\alpha - 1)z_i d_i$
 - **Inject:** $h' = h + \delta d_i$
 
-For a feature set $S$, FeatureLens sums the individual ablation/scale deltas before patching the original residual:
+For a feature set $S$:
 
-$$h' = h + \sum_{i \in S} \Delta z_i d_i.$$
+$$h' = h + \sum_{i \in S}\Delta z_i d_i.$$
 
-The app never replaces $h$ with the complete SAE reconstruction, so SAE reconstruction error is not introduced
-as a causal confound.
+FeatureLens patches the delta into the **original residual**; it never replaces the residual with the complete SAE reconstruction.
 
-### Full-continuation scoring
+### v0.4 control discipline
 
-For a user-supplied target continuation, v0.3 concatenates its token IDs to the prompt and computes teacher-forced
-log probabilities for **every target token**. The primary length-comparable live/offline statistic is the change in
-**mean log probability per target token**. The next-token distribution is still reported separately.
+Batched experiments include an explicit **zero-edit row**. Causal effects are measured against that row rather than a separately executed baseline, which removes batch-vs-single floating-point drift from the measured effect. Random specificity uses an ensemble of norm-matched residual directions rather than one arbitrary seed.
 
 ### Evidence ladder
 
-1. **Reconstruction:** does the SAE represent the residual reasonably well?
-2. **Prediction:** does a feature predict a controlled concept on held-out paraphrase groups?
-3. **Robustness:** does the sparse representation remain stable across a paraphrase?
-4. **Single-feature intervention:** does changing one feature alter downstream behaviour?
-5. **Feature-set intervention:** does jointly editing a sparse subspace reveal distributed causal influence?
-6. **Specificity:** are those effects larger than norm-matched random residual perturbations?
-7. **Dose-response:** does effect size change coherently as a feature coefficient is varied?
+1. SAE reconstruction quality.
+2. Held-out feature/concept prediction.
+3. Local and prompt-wide paraphrase robustness.
+4. Controlled live concept contrast.
+5. Single-feature causal intervention and dose-response.
+6. Joint feature-set intervention and set-size sensitivity.
+7. Individual-vs-joint non-additivity.
+8. Specificity relative to norm-matched random controls.
 
-A high AUROC or high paraphrase overlap alone remains correlational evidence.
+Association, robustness, and intervention evidence remain separate claims.
 """
         )
 
-    gr.Markdown(
-        "<small>Built with PyTorch, Transformers, Qwen3-1.7B-Base and Qwen-Scope residual-stream SAEs. "
-        "FeatureLens is independent of thesis code and thesis datasets.</small>"
+    gr.HTML(
+        '<footer class="classic-footer">Built with PyTorch, Transformers, Qwen3-1.7B-Base and Qwen-Scope '
+        'residual-stream SAEs. FeatureLens is independent of thesis code and thesis datasets.<br><br>'
+        'End of workbench.</footer>'
     )
 
-    # Event wiring is kept together so cross-tab state is explicit.
+    # Event wiring.
     analyze_btn.click(
         analyze_prompt,
         inputs=[prompt, layer, token_index, top_n],
@@ -864,7 +1201,12 @@ A high AUROC or high paraphrase overlap alone remains correlational evidence.
             feature_plot,
             feature_id,
             feature_set_ids,
+            contrast_feature_id,
+            contrast_layer,
             analysis_metrics,
+            feature_set_location,
+            contrast_location,
+            feature_tsv,
         ],
     )
     mode.change(mode_help, inputs=[mode], outputs=[coefficient])
@@ -877,37 +1219,64 @@ A high AUROC or high paraphrase overlap alone remains correlational evidence.
             intervention_metrics,
             token_prob_table,
             target_token_table,
+            token_prob_tsv,
+            target_token_tsv,
         ],
     )
     dose_btn.click(
         run_dose_response,
         inputs=[prompt, layer, token_index, feature_id, target_text],
-        outputs=[dose_table, dose_plot, dose_metrics],
+        outputs=[dose_table, dose_plot, dose_metrics, dose_tsv],
     )
     set_mode.change(set_mode_help, inputs=[set_mode], outputs=[set_coefficient])
     set_btn.click(
         run_feature_set,
         inputs=[prompt, layer, token_index, feature_set_ids, set_mode, set_coefficient, set_target],
-        outputs=[set_feature_table, set_metrics, set_target_table],
+        outputs=[set_feature_table, set_metrics, set_target_table, set_feature_tsv, set_target_tsv],
     )
     set_sweep_btn.click(
         run_feature_set_sweep,
         inputs=[prompt, layer, token_index, set_sweep_target],
-        outputs=[set_sweep_table, set_sweep_plot, set_sweep_note],
+        outputs=[set_sweep_table, set_sweep_plot, set_sweep_note, set_sweep_tsv],
+    )
+    interaction_btn.click(
+        run_feature_interaction,
+        inputs=[prompt, layer, token_index, feature_set_ids, interaction_target],
+        outputs=[interaction_table, interaction_metrics, interaction_plot, interaction_tsv],
+    )
+    contrast_btn.click(
+        run_concept_contrast,
+        inputs=[contrast_feature_id, contrast_layer, contrast_n],
+        outputs=[contrast_metrics, contrast_table, contrast_plot, contrast_tsv],
     )
     para_btn.click(
         run_paraphrase_compare,
         inputs=[para_a, para_b, para_layer, para_idx_a, para_idx_b, para_top_n],
-        outputs=[para_tokens_a, para_tokens_b, para_metrics, para_table, para_plot],
+        outputs=[para_tokens_a, para_tokens_b, para_metrics, para_table, para_plot, para_tsv],
     )
     trajectory_btn.click(
         run_layer_sweep,
         inputs=[trajectory_prompt, trajectory_token],
-        outputs=[trajectory_tokens, trajectory_table, trajectory_plot],
+        outputs=[trajectory_tokens, trajectory_table, trajectory_plot, trajectory_tsv],
     )
 
+    for button, source in [
+        (feature_copy, feature_tsv),
+        (token_prob_copy, token_prob_tsv),
+        (target_token_copy, target_token_tsv),
+        (dose_copy, dose_tsv),
+        (set_feature_copy, set_feature_tsv),
+        (set_target_copy, set_target_tsv),
+        (set_sweep_copy, set_sweep_tsv),
+        (interaction_copy, interaction_tsv),
+        (contrast_copy, contrast_tsv),
+        (para_copy, para_tsv),
+        (trajectory_copy, trajectory_tsv),
+    ]:
+        _bind_copy(button, source)
+
+
 if __name__ == "__main__":
-    # Explicit CSR avoids the Gradio SSR auth-coroutine warning seen in earlier Space builds.
     demo.queue(default_concurrency_limit=1, max_size=8).launch(
         css=CSS,
         theme=THEME,

docs/HF_DEPLOY.md

@@ -9,46 +9,80 @@ On Hugging Face, `FEATURELENS_EAGER_LOAD` defaults to `1`. The runtime loads:
 - `Qwen/Qwen3-1.7B-Base`;
 - Qwen-Scope SAE layers **4, 14, 26** only.
 
-The full 28-layer SAE repository is not required by the live app.
+The live app does not need every SAE layer from the full repository.
 
-`app.py` explicitly launches with `ssr_mode=False`. This avoids the SSR/auth path that produced the earlier `get_current_user was never awaited` warning during v0.2 deployment testing.
+`app.py` launches with `ssr_mode=False`, matching the deployment path that removed the earlier SSR/auth coroutine warning during Space testing.
 
 ## GPU-decorated actions
 
-Current v0.3 callback allocations:
+Current v0.4 live actions include:
 
-- **Inspect sparse features** — 30 s;
-- **Run single-feature causal test** — 45 s;
-- **Run scale dose-response** — 35 s;
-- **Run joint feature-set causal test** — 35 s;
-- **Run 1/3/5-feature ablation sweep** — 35 s;
-- **Compare paraphrase representations** — 30 s;
-- **Compare layers** — 35 s.
+- **Inspect sparse features**;
+- **Run single-feature causal test**;
+- **Run scale dose-response**;
+- **Run joint feature-set causal test**;
+- **Run 1/3/5-feature ablation sweep**;
+- **Run individual-vs-joint decomposition**;
+- **Run controlled concept contrast**;
+- **Compare paraphrase representations**;
+- **Compare layers**.
 
-These durations are allocation ceilings, not expected runtimes.
+Allocation durations in `app.py` are ceilings requested from ZeroGPU, not expected wall-clock runtimes.
 
-## Batched interventions
+## Batch-first causal execution
 
-v0.3 deliberately batches experiment conditions inside one GPU callback:
+v0.4 deliberately batches related conditions so stronger diagnostics do not require a separate GPU callback for every condition.
 
-- all six dose-response multipliers share one edited forward after the baseline;
-- targeted/random conditions for k=1/3/5 feature-set ablation share one edited forward after the baseline;
-- full-target SAE and random-control scoring is batched when possible.
+Examples:
 
-This keeps the stronger diagnostics compatible with a quota-limited interactive Space.
+- scale dose-response stacks the six multipliers in one edited batch;
+- single-feature causal tests stack zero edit, one targeted SAE edit, and eight norm-matched random controls;
+- 1/3/5 feature-set sensitivity batches targeted edits and control ensembles;
+- individual-vs-joint decomposition batches all individual ablations plus the joint ablation;
+- controlled concept contrast evaluates its balanced prompt batch together.
 
-## Greedy generation vs target scoring
+The primary causal reference inside each experiment is a **batched zero-edit row**. This prevents batch-vs-single floating-point drift from being mistaken for an intervention effect.
 
-The single-feature causal test still runs baseline and edited greedy generation because the visible text comparison is useful for a demo. Probability-level evidence uses teacher-forced full-continuation scoring, because deterministic text can remain unchanged despite meaningful logit shifts.
+## Greedy generation vs probability-level scoring
 
-The feature-set and set-size panels intentionally avoid extra free-running generations and focus on causal probability metrics.
+The single-feature causal test retains baseline and edited greedy generation because the visible text comparison is useful in a public demo.
+
+The primary targeted causal metric uses teacher-forced **full-continuation** log-probability scoring. Greedy text may remain unchanged while probability-level metrics move.
+
+The heavier feature-set, set-size, interaction, and contrast panels avoid unnecessary free-running generations.
+
+## Clipboard export
+
+Major output tables include a dedicated **Copy table with headers** action. The app serializes the result as tab-separated text before invoking the browser clipboard API. This makes pasted output self-describing and spreadsheet-friendly.
+
+If browser clipboard permission is unavailable, the frontend uses a temporary-textarea fallback.
+
+## Embedded-Space layout
+
+The app uses:
+
+- restrained serif typography;
+- small corner radii rather than pill-heavy controls;
+- explicit bottom padding on the Gradio container and tab contents;
+- a visible footer with `End of workbench.`.
+
+These changes prevent app-owned content from ending abruptly. The outer Hugging Face embedding frame may still resize asynchronously; that behavior is outside the Python layout itself.
 
 ## Offline benchmark
 
-Do **not** run the full research benchmark in the public Space. Run:
+Do **not** run the complete research benchmark as an interactive public-Space action.
+
+Run on separate CUDA compute:
+
+```bash
+python3 experiments/run_all.py
+```
+
+Both causal runners accept a configurable random-control count. For more stable offline control estimates, increase the value if compute permits, for example:
 
 ```bash
-python experiments/run_all.py
+python3 -m experiments.run_causal --random-controls 16
+python3 -m experiments.run_feature_sets --random-controls 16
 ```
 
-on separate CUDA compute, then commit only the small report/catalog/CSV/figure artifacts you want the Space to display. Large activation arrays remain gitignored.
+Then commit only the small report/catalog/CSV/figure artifacts intended for presentation. Large activation arrays remain gitignored.

docs/METHODOLOGY.md

@@ -1,37 +1,83 @@
-# Methodology
+# FeatureLens methodology
 
-## Primary hypothesis
+## Primary question
 
-A sparse feature that predicts a semantic category is not automatically a causal mechanism for behavior. FeatureLens therefore evaluates reconstruction, association, robustness, and causal intervention separately.
+FeatureLens separates **representation** from **causal influence**.
+
+A sparse feature can predict a concept because it correlates with useful information in the residual stream. That does not imply that changing that feature direction will specifically change model behaviour. The project therefore evaluates four distinct properties:
+
+1. reconstruction quality;
+2. predictive association;
+3. robustness across paraphrases;
+4. causal sensitivity under controlled residual interventions.
+
+---
+
+## Model and sparse dictionaries
+
+The live workbench uses `Qwen/Qwen3-1.7B-Base` and Qwen-Scope residual-stream SAEs at layers `4`, `14`, and `26`.
+
+Each selected residual location is encoded with the corresponding layer-specific SAE. Feature IDs are meaningful only **within one SAE dictionary**; numerical IDs must not be compared as if they were shared semantics across layers.
+
+---
 
 ## Discovery data
 
-Seven controlled concepts are represented by 16 prompt pairs per concept. Each pair contains two paraphrases. The split is grouped by `pair_id`, so lexical near-duplicates never cross train and held-out test.
+The controlled discovery benchmark contains seven concept groups:
 
-The offline discovery benchmark uses the final prompt-token residual because it summarizes the complete prompt prefix and keeps cached tensors small. The live workbench remains token-selectable.
+- code;
+- mathematics;
+- positive sentiment;
+- negative sentiment;
+- French language;
+- factual entities;
+- uncertainty.
 
-## Sparse feature selection
+Each concept contains 16 paraphrase pairs, two prompts per pair, for 224 prompts total.
 
-For each configured residual layer, FeatureLens stores the TopK SAE code. Candidate features must fire often enough on the training split. They are ranked using training AUROC with activation-rate contrast as a tie-break.
+Train/test splitting is grouped by `pair_id`, so the two paraphrases from the same source pair cannot leak across train and held-out test.
 
-Held-out AUROC and F1 are computed **after** selection. The test split is not used to pick the winning feature.
+The offline discovery benchmark uses the final prompt-token residual. The live workbench remains token-selectable.
 
-## Dense baseline
+---
 
-A multinomial logistic-regression probe is fit to dense residual vectors at the same layers. This asks whether concept information exists in the representation even when no individual sparse feature isolates it cleanly.
+## Sparse feature discovery
 
-## Paraphrase robustness
+For each configured layer, FeatureLens records the TopK SAE code at the chosen prompt location.
 
-Sparse representation stability is measured with:
+Candidate features are selected **using the training split only**. Training AUROC is the primary selection score, with activation-rate contrast used as a tie-break. Held-out AUROC and F1 are computed only after feature selection.
 
-- TopK support Jaccard;
-- sparse activation cosine.
+This prevents the project from selecting whichever SAE feature happened to look best on held-out data.
+
+---
+
+## Dense linear-probe baseline
+
+A multinomial logistic-regression probe is fit to dense residual vectors from the same layers.
+
+The comparison asks whether concept information is linearly available in the dense representation even when no individual sparse feature cleanly isolates it.
 
-The live **Paraphrase robustness** explorer computes the same style of diagnostics for a manually supplied prompt pair. High overlap is robustness evidence only; it does not establish semantic identity of individual feature IDs.
+A result such as strong linear-probe performance but weak single-feature AUROC would support a more distributed representation rather than a clean monosemantic feature story.
 
-## Reconstruction-preserving causal edit
+---
 
-For residual `h`, selected SAE activation `z_i`, decoder direction `d_i`, and multiplier `α`:
+## Reconstruction diagnostics
+
+For residual `h` and SAE reconstruction `h_hat`, FeatureLens records:
+
+- reconstruction cosine;
+- normalized mean squared error;
+- active feature count;
+- Top-5 activation mass;
+- normalized sparse activation entropy in the live layer trajectory.
+
+These are diagnostics, not causal evidence. Reconstruction quality can also vary substantially by layer.
+
+---
+
+## Reconstruction-preserving residual interventions
+
+For selected SAE activation `z_i`, decoder direction `d_i`, and scale multiplier `α`:
 
 ```text
 ablate:   h' = h - z_i d_i
@@ -39,63 +85,212 @@ scale:    h' = h + (α - 1) z_i d_i
 inject:   h' = h + δ d_i
 ```
 
-The delta is added to the **original residual**. FeatureLens never replaces the residual with the full SAE reconstruction, avoiding reconstruction error as a causal confound.
+Only the decoded **feature delta** is added to the original residual stream. FeatureLens does **not** replace the residual with the complete SAE reconstruction.
 
-## Full-continuation target scoring
+This avoids conflating the intervention with full-reconstruction error.
 
-v0.3 scores the complete user/task target rather than only its first token.
+`inject` is intentionally interpreted differently from ablation/scaling: it tests an externally supplied decoder-direction steering coefficient even if that feature was not naturally active.
 
-Prompt token IDs are concatenated with the exact target token IDs. A teacher-forced forward pass supplies a log probability for every target token. FeatureLens stores:
+---
 
+## Full-continuation teacher-forced scoring
+
+A target such as `2x` may consist of multiple tokenizer tokens. FeatureLens therefore scores the complete target continuation, not only its first token.
+
+The exact target token IDs are appended to the prompt. Teacher-forced model logits provide a log probability for every target token.
+
+The live and offline causal metrics include:
+
+- per-target-token log probability;
 - total target sequence log probability;
-- mean log probability per target token;
-- per-token log probabilities;
-- SAE-edit deltas;
-- matched-control deltas.
+- mean target log probability per token;
+- intervention-minus-reference deltas.
 
-The primary aggregate causal metric is **Δ mean target log probability per token** because it is comparable across targets with different token lengths.
+The primary aggregate causal metric is **Δ mean target log probability per token**, because it is less directly dependent on target length than total sequence log probability.
 
-Next-token probability/rank and JS divergence remain secondary diagnostics.
+Next-token Jensen-Shannon divergence and greedy generation remain complementary diagnostics. Identical greedy outputs do not imply an intervention had zero probability-level effect.
 
-## Negative control
+---
 
-For every targeted residual perturbation, FeatureLens constructs a deterministic random residual direction with the same L2 norm and patches it at the same layer and prompt token.
+## Batched zero-edit causal reference
 
-The paired targeted-vs-random comparison asks whether the chosen SAE direction matters more than an arbitrary perturbation of equal magnitude.
+v0.3 exposed an important numerical issue: batched and separately executed model forwards can differ slightly even when the intended residual edit is zero. A nominal `1×` dose-response condition therefore showed a small non-zero effect when compared with a separately executed baseline.
 
-## Single-feature dose-response
+v0.4 treats this as instrumentation drift, not causal evidence.
 
-The live dose-response experiment is explicitly a **scale sweep**:
+Every batched causal experiment now includes an explicit zero-edit condition:
+
+```text
+Δh = 0
+```
+
+All intervention deltas in that batch are measured against this **same-execution-context reference**.
+
+For the scale dose-response, the `1×` row is the zero-edit reference itself, so its causal deltas are exactly zero by construction.
+
+When a separately executed capture forward is also needed, FeatureLens reports the single-vs-batch discrepancy as **execution-context null drift**. That diagnostic is kept separate from causal effect size.
+
+---
+
+## Norm-matched random-control ensemble
+
+A single random residual direction is a fragile negative control: by chance it can be unusually weak or unusually disruptive.
+
+For a targeted perturbation `Δh_sae`, FeatureLens generates deterministic random directions `r_j` and rescales each one so that:
+
+```text
+||r_j||_2 = ||Δh_sae||_2
+```
+
+The live app uses **8 random directions** for each targeted perturbation. Targeted and control conditions are evaluated in the same batched execution context.
+
+The live app reports:
+
+- signed random mean effect;
+- mean absolute random effect;
+- random-effect standard deviation;
+- `|targeted effect| / mean(|random effect|)`;
+- an empirical two-sided magnitude tail quantity:
+
+```text
+(1 + count(|random_j| >= |targeted|)) / (N + 1)
+```
+
+With only eight live controls this empirical value is intentionally coarse: the smallest possible value is `1/9`. It is an exploratory specificity diagnostic, **not** a conventional significance test.
+
+Offline runs can increase `--random-controls` when compute allows.
+
+---
+
+## Single-feature scale dose-response
+
+The live dose-response experiment always evaluates:
 
 ```text
 0×, 0.5×, 1×, 1.5×, 2×, 3×
 ```
 
-`0×` is ablation and `1×` is the exact no-edit control. All six residual deltas are evaluated as one batch after the baseline.
+where:
+
+- `0×` = complete ablation;
+- `1×` = zero edit;
+- `2×` = double the native coefficient.
 
-A monotonic curve would strengthen causal evidence, but monotonicity is not assumed. Non-monotonic responses are retained as results.
+All six edited residual conditions are stacked along the batch dimension and scored together. The `1×` batch row is the reference for every reported delta.
 
-## Feature-set intervention
+A monotonic relationship would strengthen a simple directional causal interpretation, but monotonicity is not required. Non-monotonic responses are retained as evidence about the model rather than “corrected” away.
 
-A concept may be distributed across multiple sparse features. For a same-layer feature set `S`, FeatureLens sums individual ablation/scale deltas:
+---
+
+## Joint feature-set interventions
+
+A concept may be distributed across multiple sparse features.
+
+For a same-layer feature set `S`, FeatureLens sums the individual decoder-direction deltas:
 
 ```text
 h' = h + Σ_i∈S Δz_i d_i
 ```
 
-Features from different SAE layers are never summed into one residual intervention.
+The live app supports joint ablation and shared-multiplier scaling. Cross-layer feature sets are never combined into one residual intervention.
+
+Additive injection is deliberately omitted from the feature-set UI because one shared additive coefficient across unrelated decoder directions has no uniquely natural interpretation.
+
+---
+
+## 1 / 3 / 5 feature-set sensitivity
+
+At the selected prompt location, FeatureLens jointly ablates the strongest active:
+
+```text
+k = 1, 3, 5
+```
+
+features.
+
+Each targeted joint perturbation receives its **own 8-direction norm-matched random ensemble**. The targeted edit, random controls, and zero-edit reference are scored in a batched execution context.
+
+Increasing `k` is not assumed to increase effect magnitude or specificity. Non-monotonic behaviour may indicate redundancy, cancellation, distributed representation, or ordinary model non-linearity.
+
+---
+
+## Individual-vs-joint non-additivity
+
+For a selected set of 2–5 active features, FeatureLens separately evaluates:
+
+```text
+feature 1 ablation
+feature 2 ablation
+...
+joint ablation
+zero-edit reference
+```
+
+Let `e_i` be the Δ mean target log probability/token for the individual ablation of feature `i`, and `e_joint` the joint effect.
+
+FeatureLens reports:
+
+```text
+additive expectation = Σ_i e_i
+interaction excess   = e_joint - Σ_i e_i
+```
+
+and a normalized interaction value scaled by the sum of absolute individual effects.
+
+A non-zero excess diagnoses **non-additivity under this intervention**. It does not establish that the selected SAE features directly interact with one another or form a mechanistic circuit; downstream nonlinearities can also produce non-additivity.
+
+---
+
+## Paraphrase robustness: selected-token and prompt-wide
+
+The strict selected-token comparison measures:
 
-The live app supports custom same-layer feature sets. The offline pipeline additionally selects a concept's best layer using training-only feature scores and tests its top **1 / 3 / 5** distinct features.
+- TopK feature-support Jaccard;
+- sparse activation cosine.
+
+This can be misleading when the two manually selected tokens play different roles. For example, comparing the final token `is` in one prompt with a final punctuation token in its paraphrase is not a clean semantic-anchor comparison.
+
+v0.4 therefore adds a prompt-wide profile. For each SAE feature, FeatureLens takes its maximum activation across all prompt tokens:
+
+```text
+profile_i(prompt) = max_t z_{t,i}
+```
 
-## Feature-set size control
+The two prompt-wide sparse dictionaries are then compared by support Jaccard and cosine.
 
-For each k in `1, 3, 5`, targeted joint ablation is compared with a norm-matched random residual perturbation. Increasing k is **not** assumed to increase causal specificity: a larger feature set can simply create a larger perturbation, which is why matched controls and paired statistics remain necessary.
+The selected-token and prompt-wide metrics answer different questions and are intentionally displayed together.
 
-## Statistical interpretation
+---
 
-The generated report calculates:
+## Controlled concept contrast scan
+
+The live **Feature evidence** tab provides an exploratory contrast for one selected feature.
+
+It samples a small balanced batch from the same seven controlled concept groups, using only one wording from each paraphrase pair, and measures feature activation at the final prompt token.
+
+For each concept it reports:
+
+- mean activation;
+- median activation;
+- activation rate;
+- maximum activation.
+
+This is a **diagnostic**, not the offline feature-labeling procedure. The live scan never modifies `Offline concept hint` and does not claim semantic identity from a handful of prompts.
+
+---
+
+## Statistical interpretation in the offline report
+
+The generated offline report uses paired targeted-vs-control comparisons.
+
+For a causal condition with several random controls, the report first aggregates the control ensemble for that same task/condition rather than selecting an arbitrary random row.
+
+It then uses:
 
 - bootstrap 95% confidence intervals;
-- paired sign-flip randomization tests for targeted-vs-random absolute effects.
+- paired sign-flip randomization tests;
+- targeted/random effect-size ratios.
+
+A large point-estimate ratio alone is not sufficient for a strong causal-specificity narrative if paired uncertainty remains weak.
 
-A large point-estimate ratio alone is not treated as strong causal-specificity evidence if paired uncertainty does not support it. The report preserves raw rows regardless of the narrative classification.
+FeatureLens keeps the raw rows even when the resulting conclusion is null, mixed, or contrary to the original hypothesis.

docs/VALIDATION.md

@@ -1,62 +1,87 @@
-# FeatureLens v0.3 validation guide
+# FeatureLens v0.4 validation guide
 
-This document intentionally uses the **exact labels visible in the v0.3 Gradio UI**.
+This guide intentionally uses the **exact labels visible in the v0.4 Gradio UI**. Follow it in order after every Hugging Face deployment that changes runtime or UI code.
 
-The goal is to distinguish three things:
+The tests are divided into four categories:
 
-1. software correctness;
+1. local software correctness;
 2. Hugging Face / ZeroGPU deployment correctness;
-3. scientific sanity checks.
+3. causal-instrumentation sanity checks;
+4. edge/adversarial behavior.
 
-Do not interpret one successful prompt as a scientific result. The live tests below only verify that the instrumentation behaves coherently.
+A successful live prompt is a software sanity check, **not** a scientific conclusion. Scientific claims should come from the saved offline benchmark artifacts and their paired controls.
 
 ---
 
-## A. Local software gate
+## A. Local release gate
 
-From the repository root:
+From the repository root run:
 
 ```bash
-python -m pytest -q
-python -m compileall -q app.py featurelens experiments scripts
-python scripts/release_check.py
+python3 -m pytest -q
+python3 -m compileall -q app.py featurelens experiments scripts
+python3 scripts/release_check.py
 ```
 
 Expected:
 
-- all tests pass;
-- `compileall` exits without output/error;
-- release check ends with `FeatureLens release check: PASS` and `release: v0.3.0`.
+```text
+29 passed
+FeatureLens release check: PASS
+  discovery prompts: 224
+  causal tasks: 28
+  layers: [4, 14, 26]
+  feature-set sizes: [1, 3, 5]
+  random controls: 8
+  release: v0.4.0
+```
+
+`compileall` should exit silently with status 0.
 
 Optional lint gate:
 
 ```bash
-python -m ruff check app.py featurelens experiments tests scripts
+python3 -m ruff check app.py featurelens experiments tests scripts
 ```
 
 ---
 
-## B. Hugging Face startup test
+## B. Hugging Face startup and layout
 
 ### Test B1 — container startup
 
-Open the Space container logs after a fresh rebuild.
+After a fresh Space rebuild, open the container logs.
 
-Expected launch lines:
+Expected launch line:
 
 ```text
 * Running on local URL:  http://0.0.0.0:7860
 ```
 
-The earlier warning below should **not** reappear:
+The earlier deployment warning should not return:
 
 ```text
 coroutine 'App.create_app.<locals>.get_current_user' was never awaited
 ```
 
-The launch output should also not contain `with SSR ⚡` because `app.py` uses `ssr_mode=False`.
+The launch output should not contain `with SSR ⚡` because FeatureLens launches with `ssr_mode=False`.
+
+**Pass:** the Space reaches `Running`, the UI loads, and no repeated startup exception appears.
+
+### Test B2 — page bottom / embedded Space behavior
+
+Open **Workbench**, scroll to the bottom of the full application, and then switch through **Feature sets**, **Feature evidence**, **Paraphrase robustness**, and **Layer trajectory**.
+
+Verify:
+
+- descenders such as `g`, `p`, `q`, and `y` are not clipped inside app content;
+- the last interactive element is followed by visible breathing room;
+- the footer containing `End of workbench.` can be reached;
+- labels do not overlap controls after a tab switch.
 
-Pass condition: Space reaches `Running` and the UI loads.
+Also resize the browser to roughly half desktop width.
+
+**Pass:** form rows wrap rather than overlap, controls remain readable, and the footer is reachable. If the outer Hugging Face iframe itself temporarily refuses to resize and then corrects itself after loading, record that separately from an app-level clipping failure.
 
 ---
 
@@ -64,9 +89,7 @@ Pass condition: Space reaches `Running` and the UI loads.
 
 ### Test C1 — inspect a mathematics prompt
 
-Open **Workbench**.
-
-Set:
+Open **Workbench** and set:
 
 - **Prompt**: `The derivative of x squared is`
 - **Residual layer**: `14`
@@ -75,35 +98,50 @@ Set:
 
 Click **Inspect sparse features**.
 
-Verify all of the following:
+Verify:
 
-1. **Prompt tokens** appears directly above token-like boxes. One token has a stronger outline; this is the selected prompt token.
-2. **Analysis metrics** appears and includes:
+1. **Prompt tokens** appears and one token has the stronger selected outline.
+2. **Analysis metrics** reports:
+   - `Layer 14`;
+   - the resolved prompt token index;
    - active SAE features;
    - reconstruction cosine;
    - NMSE;
    - Top-5 activation mass.
-3. **Strongest active SAE features** contains 12 rows unless fewer than 12 are available.
-4. **Activation profile** contains the same displayed feature IDs as the table.
-5. **Single feature id** is populated with those feature IDs.
-6. Open **Feature sets** and confirm **Feature set** is populated, with up to the first 3 displayed features selected by default.
+3. **Strongest active SAE features** contains 12 rows unless fewer are available.
+4. **Activation profile** contains the same displayed feature IDs.
+5. **Single feature id** is populated.
+6. Open **Feature sets** and verify **Feature set** is populated with active feature IDs.
+7. Open **Feature evidence** and verify **Feature id** is populated.
+
+Basic bounds:
 
-Sanity checks:
+- reconstruction cosine is finite and lies in `[-1, 1]`;
+- NMSE is finite and non-negative;
+- feature IDs lie in `[0, 32767]`;
+- displayed TopK activations are non-negative.
 
-- reconstruction cosine must be finite and normally lie in `[-1, 1]`;
-- NMSE must be finite and non-negative;
-- feature IDs must lie in `[0, 32767]`;
-- activations should be non-negative for the TopK ReLU SAE.
+### Test C2 — copy feature table with headers
+
+Under **Strongest active SAE features**, click **Copy table with headers** and paste into a plain-text editor.
+
+The **first pasted line must contain the column names**, tab-separated, for example:
+
+```text
+Rank	Feature ID	Activation	Offline concept hint
+```
+
+The following lines must contain the table rows.
+
+Repeat by pasting into a spreadsheet. Columns should split naturally on tabs.
 
 ---
 
 ## D. Single-feature causal test
 
-Use the same Workbench prompt/location from Test C1.
+Continue from Test C1 and choose the strongest value in **Single feature id**.
 
-Choose the strongest value in **Single feature id**.
-
-### Test D1 — ablation with a multi-token target
+### Test D1 — active-feature ablation with a multi-token target
 
 Set:
 
@@ -115,149 +153,161 @@ Click **Run single-feature causal test**.
 
 Verify:
 
-1. **Baseline greedy generation** is populated.
-2. **SAE-edited greedy generation** is populated.
-3. **Next-token distribution shift** is populated.
+1. **Baseline greedy generation** and **SAE-edited greedy generation** are populated.
+2. **Next-token distribution shift** is populated.
+3. **Target continuation token-by-token score** has one row for every token used to encode `2x`.
 4. The metrics report:
    - original feature activation;
    - Δ coefficient;
    - perturbation L2;
    - next-token JS;
-   - random-control JS;
-   - full target continuation token count;
-   - baseline / SAE / random sequence log p;
-   - SAE and random Δ sequence log p;
-   - SAE and random Δ mean log p/token;
-   - specificity ratio.
-5. **Target continuation token-by-token score** has one row for every token in `2x`.
+   - random-ensemble mean JS and standard deviation;
+   - number of random controls (`8`);
+   - JS magnitude ratio and empirical tail probability;
+   - execution-context null drift;
+   - full target token count;
+   - sequence and mean-per-token target effects;
+   - random-ensemble target effect statistics.
+5. For an active feature under ablation, `Δ coefficient ≈ -original feature activation`.
+
+The two greedy generations are **allowed to be identical**. Probability/log-probability metrics are more sensitive than deterministic argmax text.
 
-Important expected behaviour:
+### Test D2 — full-continuation table copy
 
-- ablation should report `Δ coefficient = -original activation` for an active feature;
-- targeted and random perturbation L2 norms should be matched internally;
-- greedy generations **may be identical** even when log-probability and JS metrics differ. This is not a failure.
+Click **Copy table with headers** under **Target continuation token-by-token score** and paste into a text editor.
 
-### Test D2 — scale
+The first line must contain all target-score headers, followed by one line per target token.
+
+### Test D3 — scale
 
 Set:
 
 - **Single-feature intervention**: `scale`
 - **Feature multiplier**: `2`
-- keep **Target continuation (optional)**: `2x`
+- **Target continuation (optional)**: `2x`
 
 Click **Run single-feature causal test**.
 
-Expected:
-
-- for an active feature, `Δ coefficient ≈ +original activation`;
-- full-continuation metrics are present;
-- output need not differ at the text level.
+For an active feature, expect `Δ coefficient ≈ +original feature activation`.
 
-### Test D3 — inject
+### Test D4 — inject
 
 Set:
 
 - **Single-feature intervention**: `inject`
 - **Additive feature coefficient**: `5`
-- keep target `2x`.
+- **Target continuation (optional)**: `2x`
+
+Click **Run single-feature causal test**.
 
 Expected:
 
-- `Δ coefficient = +5` regardless of the original feature activation;
-- perturbation L2 is finite;
-- full-continuation metrics are present.
+- `Δ coefficient = +5` regardless of native activation;
+- perturbation L2 is finite and non-zero;
+- the random ensemble remains norm-matched to the resulting residual perturbation.
 
 ---
 
-## E. Single-feature scale dose-response
+## E. Numerical-null / scale dose-response test
 
-Keep the Test C1 prompt/location, strongest **Single feature id**, and target `2x`.
+This is the **critical v0.4 regression test** for the small non-zero `1×` drift observed in v0.3.
 
-Open **Single-feature scale dose-response**.
+Keep the Workbench prompt/location and selected active feature from Test C1. Keep **Target continuation (optional)** set to `2x`.
 
-Click **Run scale dose-response**.
-
-This test has no ambiguous intervention mode: the panel is **always a scale sweep**.
+Open **Scale dose-response** and click **Run scale dose-response**.
 
 Expected rows in **Scale dose-response measurements**:
 
 ```text
-0.0
+0
 0.5
-1.0
+1
 1.5
-2.0
-3.0
+2
+3
 ```
 
-Interpretation of the multiplier:
+The experiment is always a scale sweep:
 
 - `0×` = ablation;
-- `0.5×` = halve the original activation;
-- `1×` = no intervention;
-- `1.5×` = increase by 50%;
+- `0.5×` = half native activation;
+- `1×` = batched no-edit reference;
+- `1.5×` = 1.5 times native activation;
 - `2×` = double;
 - `3×` = triple.
 
-Critical no-op sanity check for the `1×` row:
+### Required `1×` row
 
-- `Δ feature coefficient ≈ 0`;
-- `Perturbation L2 ≈ 0`;
-- `Δ mean log p/token ≈ 0`;
-- `Δ sequence log p ≈ 0`;
-- `Next-token JS ≈ 0`.
+The `1×` row must report, apart from harmless display formatting such as `-0.0`:
 
-The curve need not be monotonic. A non-monotonic curve is a scientific observation, not a software error, provided the `1×` no-op row is correct.
+```text
+Δ feature coefficient = 0
+Perturbation L2 = 0
+Δ mean log p/token = 0
+Δ sequence log p = 0
+Next-token JS = 0
+```
 
----
+Do **not** accept the old v0.3 behavior where the 1× row had a small non-zero causal delta. Any separately executed single-vs-batch numerical discrepancy should now appear only as an **execution-context null drift** diagnostic and must not be counted as the intervention effect.
 
-## F. Joint feature-set causal test
+The curve itself does not need to be monotonic.
 
-First run Test C1 so **Feature set** is populated.
+---
 
-Open **Feature sets**.
+## F. Feature-set causal tests
 
-### Test F1 — top three joint ablation
+Run Test C1 first so **Feature set** is populated.
 
-Use the default 3 selected values in **Feature set**.
+### Test F1 — top-three joint ablation
+
+Open **Feature sets**. Select exactly the three strongest active values in **Feature set**.
 
 Set:
 
-- **Feature-set intervention**: `ablate`
+- **Intervention**: `ablate`
 - **Target continuation**: `2x`
 
 Click **Run joint feature-set causal test**.
 
 Verify:
 
-1. **Joint intervention features** contains the selected feature IDs, original activations, and each Δ coefficient.
-2. Under ablation, each active feature's Δ coefficient is the negative of its original activation.
-3. The metrics report:
-   - selected set size;
-   - total joint perturbation L2;
-   - full target sequence / mean-per-token effects;
-   - matched random-control effects;
-   - specificity ratios.
-4. **Target continuation token-by-token score** contains all target tokens.
+- **Joint intervention features** has exactly three rows;
+- every active feature has `Δ coefficient = -original activation`;
+- the total joint perturbation L2 is finite;
+- the target continuation contains all target tokens;
+- random-control count is `8`;
+- random signed mean, random mean absolute effect, random standard deviation, magnitude ratio, and empirical tail probability are shown;
+- execution-context null drift is shown separately from causal effect.
+
+Do not require the targeted effect to exceed the random ensemble on every prompt. This is an empirical question.
 
 ### Test F2 — joint scale
 
 Set:
 
-- **Feature-set intervention**: `scale`
+- **Intervention**: `scale`
 - **Shared feature multiplier**: `2`
 
-Run again.
+Run **Run joint feature-set causal test** again.
+
+Expected: each selected active feature receives its own positive native-activation delta before decoder-direction deltas are summed.
+
+### Test F3 — copy joint tables
+
+Use **Copy table with headers** under both:
+
+- **Joint intervention features**;
+- **Target continuation token-by-token score**.
 
-Expected: every selected active feature receives its own `+original activation` coefficient delta before the decoder deltas are summed.
+For both, the first pasted line must contain the table headers.
 
 ---
 
-## G. 1/3/5-feature ablation sweep
+## G. 1/3/5 feature-set sensitivity
 
-Still in **Feature sets**.
+In **Feature sets**, set:
 
-Set **Target continuation for set-size sweep** to `2x`.
+- **Target continuation for set-size sweep**: `2x`
 
 Click **Run 1/3/5-feature ablation sweep**.
 
@@ -271,24 +321,72 @@ Expected **Feature-set size measurements** rows:
 
 For each row verify:
 
-- the feature ID list contains exactly `k` IDs;
+- exactly `k` feature IDs are listed;
 - perturbation L2 is finite;
-- SAE and random Δ mean log p/token are present;
-- specificity ratio is finite unless the random effect is numerically zero;
-- SAE and random next-token JS are present.
+- targeted Δ mean log p/token is present;
+- random-ensemble signed mean, mean absolute effect, and standard deviation are present;
+- targeted/random magnitude ratio is finite or safely handled when the random effect is numerically zero;
+- empirical tail probability lies in `[0, 1]`;
+- SAE and random next-token JS statistics are present.
+
+**Do not require monotonicity with k.** A k=3 edit may be less effective than k=1, and k=5 may reverse the effect. That can be a real non-linear response rather than a bug.
+
+---
+
+## H. Individual-vs-joint non-additivity
+
+In **Feature sets**, select exactly the three strongest active values in **Feature set**.
+
+Set:
+
+- **Target continuation for interaction test**: `2x`
 
-This sweep always performs **joint ablation of the strongest active features** at the current Workbench prompt location. It does not use **Feature-set intervention** or **Shared feature multiplier**.
+Click **Run individual-vs-joint decomposition**.
 
-Scientific sanity check: effect magnitude does **not** have to increase with k. If k=5 is weaker or less specific than k=1, retain that result.
+Verify:
+
+1. **Individual and joint ablation measurements** contains one row per selected feature plus one `Joint ablation` row.
+2. The summary reports:
+   - additive expectation = sum of individual Δ mean log p/token values;
+   - observed joint effect;
+   - interaction excess = joint − additive;
+   - normalized interaction;
+   - execution-context null drift.
+3. The joint row perturbation norm is finite.
+
+No particular sign is required. A non-zero interaction excess indicates non-additivity under this intervention, **not** proof that the selected SAE features form a direct circuit.
 
 ---
 
-## H. Paraphrase robustness
+## I. Controlled concept contrast
 
-Open **Paraphrase robustness**.
+First run Test C1. Open **Feature evidence**.
 
 Set:
 
+- **Feature id**: the strongest feature from Test C1;
+- **Residual layer**: `14`;
+- **Prompts per concept**: `4`.
+
+Click **Run controlled concept contrast**.
+
+Expected **Feature activation by controlled concept**:
+
+- exactly seven concept rows;
+- each row reports prompt count, mean activation, median activation, activation rate, and max activation;
+- the chart contains the same seven concepts;
+- the summary may identify the group with the highest mean activation but must explicitly describe the scan as exploratory.
+
+This live scan is **not allowed to rename the feature or populate `Offline concept hint`**. A semantic hint should only come from the offline train/held-out discovery pipeline.
+
+Use **Copy table with headers** and verify the first copied line contains all columns.
+
+---
+
+## J. Paraphrase robustness
+
+Open **Paraphrase robustness** and set:
+
 - **Original prompt**: `The derivative of x squared is`
 - **Paraphrase**: `Differentiate x squared with respect to x:`
 - **Residual layer**: `14`
@@ -300,28 +398,40 @@ Click **Compare paraphrase representations**.
 
 Verify:
 
-1. **Original prompt tokens** and **Paraphrase tokens** both render.
-2. **Robustness metrics** reports:
-   - full TopK feature-set Jaccard;
-   - sparse activation cosine;
-   - shared displayed top features.
-3. **Top-feature overlap** labels features as `shared`, `original only`, or `paraphrase only`.
-4. **Original vs paraphrase activation** renders both conditions with distinct muted colors.
+1. **Original prompt tokens** and **Paraphrase tokens** render.
+2. **Robustness metrics** reports two distinct comparisons:
+   - selected-token TopK Jaccard and sparse activation cosine;
+   - **prompt-wide** max-pooled Jaccard and cosine.
+3. **Top-feature overlap at selected tokens** marks features `shared`, `original only`, or `paraphrase only`.
+4. The prompt-wide metrics remain available even when the two selected final tokens play different syntactic/semantic roles.
 
 Bounds:
 
-- Jaccard must lie in `[0, 1]`;
-- sparse cosine should lie approximately in `[0, 1]` because SAE TopK activations are non-negative.
+- Jaccards lie in `[0, 1]`;
+- cosines should lie approximately in `[0, 1]` for non-negative SAE activations.
 
-Repeat with a deliberately weak/non-paraphrase second prompt. The metrics should be allowed to decrease; there is no hard-coded expected threshold.
+Do not impose an arbitrary minimum robustness threshold.
 
----
+### Test J2 — identity sanity check
 
-## I. Layer trajectory
+Use the **same exact prompt** in **Original prompt** and **Paraphrase**, with the same token indices and layer.
 
-Open **Layer trajectory**.
+Expected, within numerical precision:
 
-Set:
+```text
+selected-token Jaccard ≈ 1
+selected-token cosine ≈ 1
+prompt-wide Jaccard ≈ 1
+prompt-wide cosine ≈ 1
+```
+
+This is a strong sanity check for the comparison implementation.
+
+---
+
+## K. Layer trajectory
+
+Open **Layer trajectory** and set:
 
 - **Prompt**: `The derivative of x squared is`
 - **Prompt token index**: `-1`
@@ -331,37 +441,121 @@ Click **Compare layers**.
 Expected:
 
 - **Prompt tokens** renders;
-- **Layer diagnostics** contains rows `4`, `14`, `26`;
-- **Representation trajectory** contains:
-  - Reconstruction cosine;
-  - Top-5 mass;
-  - Activation entropy.
+- **Layer diagnostics** has exactly three rows: `4`, `14`, `26`;
+- **Representation trajectory** contains reconstruction cosine, Top-5 mass, and activation entropy.
 
-Do not compare feature ID numbers across layers. Each layer uses a separate SAE dictionary.
+Do not compare numerical feature IDs across layers. Each residual layer has its own independently learned SAE dictionary.
 
 ---
 
-## J. Adversarial / edge-case tests
+# L. Edge and adversarial tests
+
+These tests are designed to expose software or interpretation failures. They are not meant to produce attractive scientific results.
+
+## Test L1 — empty prompt
+
+In **Workbench**, clear **Prompt** completely and click **Inspect sparse features**.
+
+**Pass:** the UI displays a clear error and the Space remains alive. The container must not restart.
 
-These are intended to find bugs, not produce attractive screenshots.
+## Test L2 — out-of-range prompt token index
 
-### J1 — invalid token index
+Use the normal mathematics prompt but set **Prompt token index** to `999` and click **Inspect sparse features**.
 
-Set **Prompt token index** to an index larger than the prompt length and click **Inspect sparse features**.
+**Pass:** a clear index/range error is shown; the application remains usable afterward.
 
-Expected: a clear UI error explaining the token index is outside the prompt length.
+## Test L3 — feature-ID boundaries
+
+After a successful Workbench inspection, manually enter the following in **Single feature id**:
+
+1. `0` — valid boundary;
+2. `32767` — valid boundary;
+3. `32768` — invalid.
+
+Run **Run single-feature causal test** with a short target.
+
+**Pass:** IDs 0 and 32767 are accepted; 32768 produces a clear validation error without crashing the Space.
+
+## Test L4 — inactive-feature semantics
+
+Find a feature that has activation 0 at the selected prompt location. A practical way is to enter a valid feature ID that is not among the active TopK IDs.
+
+Set **Single-feature intervention** to `ablate` and run the causal test.
+
+Expected:
 
-### J2 — inactive custom feature
+```text
+Original feature activation ≈ 0
+Δ coefficient ≈ 0
+Perturbation L2 ≈ 0
+```
+
+The UI should state that ablation/scaling of an inactive feature has zero coefficient delta.
+
+Then switch to `inject`, set **Additive feature coefficient** to `5`, and run again.
+
+Expected: a non-zero residual perturbation is possible because injection intentionally tests the decoder direction even when the native activation is zero.
+
+## Test L5 — zero-perturbation random-control handling
+
+Continue Test L4 with the inactive feature and `ablate`.
+
+**Pass:** the zero targeted perturbation does not create `NaN`, `inf`, or a crash in random-control statistics. JS/effect values should be zero or numerical zero and ratios/p-values must be safely represented.
+
+## Test L6 — exact target whitespace
+
+For the same prompt and feature, run the target twice:
+
+```text
+2x
+```
+
+and
+
+```text
+ 2x
+```
 
-After inspection, enter a custom **Single feature id** that is not active at the selected token and choose `ablate`.
+(the second begins with a space).
 
-Expected: FeatureLens warns that ablation/scaling produces a zero feature delta for an inactive feature.
+**Pass:** FeatureLens reports the actual tokenization of each exact string and scores all returned target tokens. Different tokenizations/results are allowed.
 
-Then switch to `inject` with coefficient `5`.
+## Test L7 — required-target validation
 
-Expected: a non-zero decoder-direction perturbation is still possible.
+Clear the target and try:
 
-### J3 — negation prompt
+- **Run scale dose-response**;
+- **Run joint feature-set causal test**;
+- **Run 1/3/5-feature ablation sweep**;
+- **Run individual-vs-joint decomposition**.
+
+**Pass:** every experiment that mathematically requires a target gives a clear UI error rather than silently inventing one or failing deep in the model call.
+
+The ordinary **Run single-feature causal test** may be used without a target because next-token JS and greedy generation are still defined.
+
+## Test L8 — identical paraphrases
+
+Repeat Test J2 with the exact same text, same layer, and same token index.
+
+**Pass:** all robustness metrics are approximately 1. This is the adversarial regression check for the prompt-wide pooling code.
+
+## Test L9 — unrelated “paraphrase”
+
+Compare:
+
+```text
+The derivative of x squared is
+```
+
+with:
+
+```text
+Je voudrais réserver une table pour demain soir.
+```
+
+**Pass:** the app returns finite robustness metrics but does **not** label the prompts as semantically equivalent merely because some features overlap. No hard numerical threshold is required.
+
+## Test L10 — lexical trap / negation
 
 Inspect:
 
@@ -369,9 +563,11 @@ Inspect:
 This is not a positive review.
 ```
 
-Do not assume a positive-sentiment feature should dominate merely because the word `positive` appears.
+Then optionally run **Run controlled concept contrast** on one strongly active feature.
+
+**Pass:** the system reports activations without converting the lexical word `positive` into a hard semantic claim. `Offline concept hint` must remain whatever the offline catalog says.
 
-### J4 — mixed language
+## Test L11 — mixed-language prompt
 
 Inspect:
 
@@ -379,38 +575,81 @@ Inspect:
 The answer est probablement correct, but I am not certain.
 ```
 
-Use this only as a robustness/adversarial check. Do not retrofit semantic labels from one example.
+**Pass:** tokenization, SAE inspection, and causal controls remain finite. Do not expect a single concept feature to dominate.
 
-### J5 — target whitespace
+## Test L12 — long prompt truncation
 
-Compare target continuations `2x` and ` 2x`.
+Paste a prompt substantially longer than the configured prompt-token limit (repeat several paragraphs if needed) and click **Inspect sparse features**.
 
-They may tokenize differently. v0.3 intentionally scores the exact text entered in **Target continuation (optional)**.
+**Pass:** the request truncates safely to the configured maximum instead of causing an OOM or index corruption. **Prompt tokens** should reflect the actually processed token sequence.
+
+## Test L13 — table clipboard behavior
+
+For at least three different output tables, click **Copy table with headers** and paste into:
+
+1. a plain-text editor;
+2. a spreadsheet.
+
+**Pass:** the first row always contains headers, data are tab-separated, and embedded commas in cells do not shift spreadsheet columns.
+
+## Test L14 — rapid double click / queue safety
+
+Click one GPU-heavy action twice quickly, for example **Run single-feature causal test**.
+
+**Pass:** requests queue under the app's concurrency limit rather than corrupting shared activation hooks or crashing the runtime. Do not repeatedly hammer the button beyond this single queue test because ZeroGPU quota is limited.
+
+## Test L15 — responsive Feature Sets form
+
+At narrow browser width, open **Feature sets**.
+
+Verify the row containing:
+
+- **Intervention**;
+- **Multiplier (unused for ablation)** or **Shared feature multiplier**;
+- **Target continuation**
+
+wraps cleanly. Switch **Intervention** between `ablate` and `scale`.
+
+**Pass:** labels remain attached to the correct fields, no control text runs together, and changing the mode updates the multiplier label without shifting the target field into an ambiguous position.
 
 ---
 
-## K. Scientific benchmark acceptance
+# M. Offline scientific benchmark acceptance
 
-After the live Space is stable, run:
+After the public Space passes the live tests, run on separate CUDA compute:
 
 ```bash
-python experiments/run_all.py
+python3 experiments/run_all.py
 ```
 
-Expected new v0.3 artifact:
+v0.4 offline causal runners use:
+
+- a batched zero-edit reference;
+- targeted SAE interventions;
+- configurable norm-matched random-control ensembles (default `8`);
+- full-continuation mean log-probability effects.
+
+Expected major artifacts include:
 
 ```text
+artifacts/feature_catalog.csv
+artifacts/layer_metrics.csv
+artifacts/stability.csv
+artifacts/causal_results.csv
 artifacts/feature_set_results.csv
+artifacts/report.md
+artifacts/figures/
 ```
 
-The generated report should use `target_mean_logprob_delta` when the v0.3 causal results are present and should include `figures/feature_set_effects.png`.
-
-Before using numbers on a resume or portfolio page, manually inspect:
-
-- held-out feature selection discipline;
-- paraphrase split integrity;
-- single-feature SAE vs random paired rows;
-- feature-set SAE vs random paired rows;
-- inactive-feature rate;
-- confidence intervals / sign-flip tests;
-- whether any headline claim is actually supported by the saved raw rows.
+Before putting any number on a resume or portfolio page, manually verify:
+
+- train-only feature selection;
+- group-wise paraphrase split integrity;
+- held-out AUROC/F1;
+- reconstruction metrics by layer;
+- selected-token and paraphrase stability;
+- complete random-control ensembles for each causal condition;
+- execution-context null drift;
+- targeted-vs-random paired effect uncertainty;
+- whether single-feature and multi-feature conclusions agree or conflict;
+- whether any narrative claim is stronger than the saved raw rows support.

experiments/make_report.py

@@ -33,7 +33,7 @@ def _selected_features(catalog: pd.DataFrame) -> pd.DataFrame:
 
 
 def _effect_column(frame: pd.DataFrame) -> str:
-    """Prefer the v0.3 length-normalized full-continuation metric, with v0.2 fallback."""
+    """Prefer the full-continuation length-normalized metric, with legacy fallback."""
     if 'target_mean_logprob_delta' in frame.columns:
         return 'target_mean_logprob_delta'
     return 'target_logprob_delta'
@@ -126,15 +126,24 @@ def _paired_stats(
     random_condition: str,
     seed: int,
 ) -> dict[str, float | list[float]]:
+    """Pair one SAE effect with the mean absolute effect of its random-control ensemble."""
     metric = _effect_column(frame)
-    paired = frame.pivot_table(
-        index=index,
-        columns='condition',
-        values=metric,
-        aggfunc='first',
-    ).dropna(subset=[sae_condition, random_condition])
-    sae_abs = np.abs(paired[sae_condition].to_numpy(dtype=float))
-    random_abs = np.abs(paired[random_condition].to_numpy(dtype=float))
+    sae = (
+        frame[frame['condition'] == sae_condition]
+        .groupby(index, as_index=False)[metric]
+        .first()
+        .rename(columns={metric: 'sae_effect'})
+    )
+    random = (
+        frame[frame['condition'] == random_condition]
+        .assign(_abs_effect=lambda data: np.abs(data[metric].astype(float)))
+        .groupby(index, as_index=False)['_abs_effect']
+        .mean()
+        .rename(columns={'_abs_effect': 'random_abs_effect'})
+    )
+    paired = sae.merge(random, on=index, how='inner')
+    sae_abs = np.abs(paired['sae_effect'].to_numpy(dtype=float))
+    random_abs = paired['random_abs_effect'].to_numpy(dtype=float)
     if sae_abs.size == 0:
         return {
             'sae_abs': float('nan'),
@@ -343,7 +352,7 @@ def main() -> None:
         '- Linear baseline: multinomial logistic regression on the dense residual stream.',
         '- Single-feature causal edit: reconstruction-preserving decoder-direction delta patched into the original residual.',
         '- Feature-set causal edit: joint ablation of top same-layer concept features, evaluated at k=1/3/5 by default.',
-        '- Negative control: deterministic random residual direction matched to each SAE perturbation L2 norm.',
+        '- Negative control: ensemble of deterministic random residual directions, each matched to the SAE perturbation L2 norm.',
         '- Target metric: exact full target continuation scored teacher-forced; mean log probability per target token is the primary length-comparable effect.',
         '- Secondary diagnostics: first-token probability/rank, next-token JS divergence, and top-1 changes.',
         '- Uncertainty: bootstrap 95% confidence intervals and paired sign-flip randomization tests.',

experiments/run_causal.py

@@ -21,6 +21,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument('--catalog', type=Path, default=ARTIFACT_DIR / 'feature_catalog.csv')
     parser.add_argument('--output', type=Path, default=ARTIFACT_DIR / 'causal_results.csv')
     parser.add_argument('--seed', type=int, default=42)
+    parser.add_argument('--random-controls', type=int, default=8)
     return parser.parse_args()
 
 
@@ -65,6 +66,15 @@ def append_target(inputs: dict[str, torch.Tensor], target_ids: list[int]) -> dic
     }
 
 
+def make_random_controls(delta: torch.Tensor, seed: int, count: int) -> list[torch.Tensor]:
+    if count < 1:
+        raise ValueError('--random-controls must be at least 1.')
+    return [
+        normalized_random_control(delta, seed=int(seed) + 104729 * idx)
+        for idx in range(int(count))
+    ]
+
+
 @torch.inference_mode()
 def main() -> None:
     args = parse_args()
@@ -117,56 +127,56 @@ def main() -> None:
                 capture['hidden'] = hidden_from_output(output).detach()
 
         handle = model.model.layers[layer].register_forward_hook(capture_hook)
-        baseline_out = model(**full_inputs, use_cache=False)
+        single_baseline_out = model(**full_inputs, use_cache=False)
         handle.remove()
-
-        baseline_logits = baseline_out.logits[0]
-        baseline_next = baseline_logits[prompt_len - 1]
-        baseline_seq, baseline_mean, _ = sequence_logprob_summary(
-            baseline_logits,
+        single_baseline_logits = single_baseline_out.logits[0]
+        _, single_baseline_mean, _ = sequence_logprob_summary(
+            single_baseline_logits,
             prompt_length=prompt_len,
             target_ids=target_ids,
         )
+
         residual = capture['hidden'][0, prompt_len - 1]
         encoding = sae.encode(residual)
         original_activation = encoding.activation_for(feature_id)
-        target_id = target_ids[0]
-        baseline_prob = float(torch.softmax(baseline_next.float(), dim=-1)[target_id].item())
-        baseline_rank = int((baseline_next > baseline_next[target_id]).sum().item()) + 1
-        baseline_top1 = int(torch.argmax(baseline_next).item())
 
         specs = [
             ('ablate', InterventionSpec('ablate', 0.0)),
             ('amplify_2x', InterventionSpec('scale', 2.0)),
         ]
-        condition_meta: list[tuple[str, str, InterventionSpec, torch.Tensor, float]] = []
+        condition_meta: list[tuple[str, str, int, InterventionSpec, torch.Tensor, float]] = []
         for spec_idx, (intervention_name, spec) in enumerate(specs):
             delta = residual_delta(sae.decoder_direction(feature_id), original_activation, spec)
-            control_delta = normalized_random_control(
+            condition_meta.append(
+                (
+                    intervention_name,
+                    'sae_feature',
+                    -1,
+                    spec,
+                    delta,
+                    float(spec.delta_activation(original_activation)),
+                )
+            )
+            controls = make_random_controls(
                 delta,
-                seed=args.seed + task_idx * 101 + spec_idx,
+                seed=args.seed + task_idx * 1009 + spec_idx * 100_003,
+                count=args.random_controls,
             )
-            condition_meta.extend(
-                [
-                    (
-                        intervention_name,
-                        'sae_feature',
-                        spec,
-                        delta,
-                        float(spec.delta_activation(original_activation)),
-                    ),
+            for control_id, control_delta in enumerate(controls):
+                condition_meta.append(
                     (
                         intervention_name,
                         'random_norm_matched',
+                        control_id,
                         spec,
                         control_delta,
                         math.nan,
-                    ),
-                ]
-            )
+                    )
+                )
 
-        repeated = {key: value.repeat(len(condition_meta), 1) for key, value in full_inputs.items()}
-        deltas = torch.stack([item[3] for item in condition_meta], dim=0)
+        zero = torch.zeros_like(condition_meta[0][4])
+        deltas = torch.stack([zero, *[item[4] for item in condition_meta]], dim=0)
+        repeated = {key: value.repeat(deltas.shape[0], 1) for key, value in full_inputs.items()}
         applied = {'done': False}
 
         def batch_edit_hook(_module, _inp, output):
@@ -175,8 +185,7 @@ def main() -> None:
             hidden = hidden_from_output(output)
             modified = hidden.clone()
             modified[:, prompt_len - 1, :] = (
-                modified[:, prompt_len - 1, :]
-                + deltas.to(hidden.device, hidden.dtype)
+                modified[:, prompt_len - 1, :] + deltas.to(hidden.device, hidden.dtype)
             )
             applied['done'] = True
             return replace_hidden(output, modified)
@@ -185,7 +194,26 @@ def main() -> None:
         edited_out = model(**repeated, use_cache=False)
         hook.remove()
 
-        for row_idx, (intervention_name, condition, spec, applied_delta, delta_activation) in enumerate(condition_meta):
+        baseline_logits = edited_out.logits[0]
+        baseline_next = baseline_logits[prompt_len - 1]
+        baseline_seq, baseline_mean, _ = sequence_logprob_summary(
+            baseline_logits,
+            prompt_length=prompt_len,
+            target_ids=target_ids,
+        )
+        execution_drift_mean = float(baseline_mean - single_baseline_mean)
+        execution_drift_js = js_divergence_from_logits(
+            single_baseline_logits[prompt_len - 1], baseline_next
+        )
+        target_id = target_ids[0]
+        baseline_prob = float(torch.softmax(baseline_next.float(), dim=-1)[target_id].item())
+        baseline_rank = int((baseline_next > baseline_next[target_id]).sum().item()) + 1
+        baseline_top1 = int(torch.argmax(baseline_next).item())
+
+        for row_idx, (intervention_name, condition, control_id, spec, applied_delta, delta_activation) in enumerate(
+            condition_meta,
+            start=1,
+        ):
             modified_logits = edited_out.logits[row_idx]
             modified_next = modified_logits[prompt_len - 1]
             modified_prob = float(torch.softmax(modified_next.float(), dim=-1)[target_id].item())
@@ -212,9 +240,12 @@ def main() -> None:
                     'feature_activation': original_activation,
                     'intervention': intervention_name,
                     'condition': condition,
+                    'control_id': control_id,
+                    'random_control_count': args.random_controls,
                     'delta_activation': delta_activation,
                     'perturbation_l2': float(torch.linalg.vector_norm(applied_delta.float()).item()),
-                    # First-token metrics retained for backwards compatibility and local diagnostics.
+                    'execution_context_mean_logprob_drift': execution_drift_mean,
+                    'execution_context_js_drift': execution_drift_js,
                     'baseline_target_prob': baseline_prob,
                     'modified_target_prob': modified_prob,
                     'target_prob_delta': modified_prob - baseline_prob,
@@ -225,7 +256,6 @@ def main() -> None:
                     'baseline_target_rank': baseline_rank,
                     'modified_target_rank': modified_rank,
                     'target_rank_delta': modified_rank - baseline_rank,
-                    # v0.3 primary target metric: exact full continuation, teacher-forced.
                     'baseline_target_sequence_logprob': baseline_seq,
                     'modified_target_sequence_logprob': modified_seq,
                     'target_sequence_logprob_delta': modified_seq - baseline_seq,

experiments/run_feature_sets.py

@@ -22,6 +22,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument('--output', type=Path, default=ARTIFACT_DIR / 'feature_set_results.csv')
     parser.add_argument('--sizes', type=int, nargs='+', default=[1, 3, 5])
     parser.add_argument('--seed', type=int, default=42)
+    parser.add_argument('--random-controls', type=int, default=8)
     return parser.parse_args()
 
 
@@ -44,6 +45,14 @@ def append_target(inputs: dict[str, torch.Tensor], target_ids: list[int]) -> dic
     }
 
 
+def make_random_controls(delta: torch.Tensor, seed: int, count: int) -> list[torch.Tensor]:
+    if count < 1:
+        raise ValueError('--random-controls must be at least 1.')
+    return [
+        normalized_random_control(delta, seed=int(seed) + 104729 * idx)
+        for idx in range(int(count))
+    ]
+
 
 @torch.inference_mode()
 def main() -> None:
@@ -93,7 +102,6 @@ def main() -> None:
             raise RuntimeError(f"Target tokenization empty for task {task['id']}")
         target_ids = [int(x) for x in target_ids]
         full_inputs = append_target(prompt_inputs, target_ids)
-
         capture: dict = {}
 
         def capture_hook(_module, _inp, output):
@@ -101,12 +109,11 @@ def main() -> None:
                 capture['hidden'] = hidden_from_output(output).detach()
 
         handle = model.model.layers[layer].register_forward_hook(capture_hook)
-        baseline_out = model(**full_inputs, use_cache=False)
+        single_baseline_out = model(**full_inputs, use_cache=False)
         handle.remove()
-        baseline_logits = baseline_out.logits[0]
-        baseline_next = baseline_logits[prompt_len - 1]
-        baseline_seq, baseline_mean, _ = sequence_logprob_summary(
-            baseline_logits,
+        single_logits = single_baseline_out.logits[0]
+        _, single_mean, _ = sequence_logprob_summary(
+            single_logits,
             prompt_length=prompt_len,
             target_ids=target_ids,
         )
@@ -114,7 +121,7 @@ def main() -> None:
         encoding = sae.encode(residual)
 
         valid_sizes = [size for size in sizes if size <= len(candidate_ids)]
-        condition_meta: list[tuple[int, str, list[int], torch.Tensor]] = []
+        condition_meta: list[tuple[int, str, int, list[int], torch.Tensor]] = []
         for size in valid_sizes:
             feature_ids = candidate_ids[:size]
             activations = [encoding.activation_for(feature_id) for feature_id in feature_ids]
@@ -124,19 +131,20 @@ def main() -> None:
                 activations,
                 InterventionSpec('ablate', 0.0),
             )
-            control = normalized_random_control(
+            condition_meta.append((size, 'sae_feature_set', -1, feature_ids, delta))
+            controls = make_random_controls(
                 delta,
-                seed=args.seed + task_idx * 101 + size,
-            )
-            condition_meta.extend(
-                [
-                    (size, 'sae_feature_set', feature_ids, delta),
-                    (size, 'random_norm_matched', feature_ids, control),
-                ]
+                seed=args.seed + task_idx * 1009 + size * 100_003,
+                count=args.random_controls,
             )
-
-        repeated = {key: value.repeat(len(condition_meta), 1) for key, value in full_inputs.items()}
-        deltas = torch.stack([item[3] for item in condition_meta])
+            for control_id, control in enumerate(controls):
+                condition_meta.append(
+                    (size, 'random_norm_matched', control_id, feature_ids, control)
+                )
+
+        zero = torch.zeros_like(condition_meta[0][4])
+        deltas = torch.stack([zero, *[item[4] for item in condition_meta]], dim=0)
+        repeated = {key: value.repeat(deltas.shape[0], 1) for key, value in full_inputs.items()}
         applied = {'done': False}
 
         def edit_hook(_module, _inp, output):
@@ -154,7 +162,20 @@ def main() -> None:
         edited_out = model(**repeated, use_cache=False)
         hook.remove()
 
-        for row_idx, (size, condition, feature_ids, applied_delta) in enumerate(condition_meta):
+        baseline_logits = edited_out.logits[0]
+        baseline_next = baseline_logits[prompt_len - 1]
+        baseline_seq, baseline_mean, _ = sequence_logprob_summary(
+            baseline_logits,
+            prompt_length=prompt_len,
+            target_ids=target_ids,
+        )
+        execution_drift_mean = float(baseline_mean - single_mean)
+        execution_drift_js = js_divergence_from_logits(single_logits[prompt_len - 1], baseline_next)
+
+        for row_idx, (size, condition, control_id, feature_ids, applied_delta) in enumerate(
+            condition_meta,
+            start=1,
+        ):
             logits = edited_out.logits[row_idx]
             seq_logp, mean_logp, _ = sequence_logprob_summary(
                 logits,
@@ -174,7 +195,11 @@ def main() -> None:
                     'feature_ids': ','.join(str(x) for x in feature_ids),
                     'active_selected_features': int(active_count),
                     'condition': condition,
+                    'control_id': control_id,
+                    'random_control_count': args.random_controls,
                     'perturbation_l2': float(torch.linalg.vector_norm(applied_delta.float()).item()),
+                    'execution_context_mean_logprob_drift': execution_drift_mean,
+                    'execution_context_js_drift': execution_drift_js,
                     'baseline_target_sequence_logprob': baseline_seq,
                     'modified_target_sequence_logprob': seq_logp,
                     'target_sequence_logprob_delta': seq_logp - baseline_seq,

featurelens/config.py

@@ -27,6 +27,8 @@ class Settings:
     d_model: int = 2_048
     max_prompt_tokens: int = int(os.getenv('FEATURELENS_MAX_PROMPT_TOKENS', '256'))
     max_new_tokens: int = int(os.getenv('FEATURELENS_MAX_NEW_TOKENS', '32'))
+    live_random_controls: int = int(os.getenv('FEATURELENS_LIVE_RANDOM_CONTROLS', '8'))
+    contrast_prompts_per_concept: int = int(os.getenv('FEATURELENS_CONTRAST_PROMPTS_PER_CONCEPT', '4'))
     eager_load: bool = os.getenv(
         'FEATURELENS_EAGER_LOAD', '1' if os.getenv('SPACE_ID') else '0'
     ).lower() in {'1', 'true', 'yes', 'on'}

featurelens/runtime.py

@@ -4,6 +4,8 @@ import hashlib
 import html
 import math
 import os
+import json
+from pathlib import Path
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass
@@ -68,7 +70,12 @@ class InterventionResult:
     perturbation_norm: float
     js_divergence: float
     random_js_divergence: float
+    random_js_std: float
     js_specificity_ratio: float
+    js_empirical_p: float
+    random_control_count: int
+    execution_drift_js: float
+    execution_drift_mean_logprob: float | None
     target_text: str
     target_token_count: int
     target_tokens: list[str]
@@ -82,7 +89,10 @@ class InterventionResult:
     random_sequence_logprob_delta: float | None
     mean_logprob_delta: float | None
     random_mean_logprob_delta: float | None
+    random_abs_mean_logprob_delta: float | None
+    random_mean_logprob_std: float | None
     target_specificity_ratio: float | None
+    target_empirical_p: float | None
     target_token_rows: list[list[object]]
     top_token_rows: list[list[object]]
 
@@ -98,6 +108,8 @@ class LayerSweepResult:
 class DoseResponseResult:
     feature_activation: float
     target_tokens: list[str]
+    execution_drift_mean_logprob: float
+    execution_drift_js: float
     rows: list[list[object]]
 
 
@@ -108,7 +120,12 @@ class FeatureSetResult:
     perturbation_norm: float
     js_divergence: float
     random_js_divergence: float
+    random_js_std: float
     js_specificity_ratio: float
+    js_empirical_p: float
+    random_control_count: int
+    execution_drift_mean_logprob: float
+    execution_drift_js: float
     baseline_sequence_logprob: float
     modified_sequence_logprob: float
     random_sequence_logprob: float
@@ -116,7 +133,10 @@ class FeatureSetResult:
     random_sequence_logprob_delta: float
     mean_logprob_delta: float
     random_mean_logprob_delta: float
+    random_abs_mean_logprob_delta: float
+    random_mean_logprob_std: float
     target_specificity_ratio: float
+    target_empirical_p: float
     target_tokens: list[str]
     target_token_rows: list[list[object]]
 
@@ -124,9 +144,35 @@ class FeatureSetResult:
 @dataclass
 class FeatureSetSweepResult:
     target_tokens: list[str]
+    random_control_count: int
+    execution_drift_mean_logprob: float
+    execution_drift_js: float
     rows: list[list[object]]
 
 
+@dataclass
+class FeatureInteractionResult:
+    feature_ids: list[int]
+    target_tokens: list[str]
+    rows: list[list[object]]
+    additive_expected_mean_delta: float
+    joint_mean_delta: float
+    interaction_excess_mean_delta: float
+    normalized_interaction: float
+    execution_drift_mean_logprob: float
+
+
+@dataclass
+class ConceptContrastResult:
+    feature_id: int
+    layer: int
+    prompts_per_concept: int
+    rows: list[list[object]]
+    chart_rows: list[list[object]]
+    leading_concept: str
+    leading_ratio: float
+
+
 @dataclass
 class ParaphraseResult:
     tokens_a: list[str]
@@ -135,6 +181,8 @@ class ParaphraseResult:
     token_index_b: int
     topk_jaccard: float
     sparse_cosine: float
+    promptwide_jaccard: float
+    promptwide_cosine: float
     shared_top_n: int
     top_n: int
     rows: list[list[object]]
@@ -353,6 +401,66 @@ class FeatureLensRuntime:
         payload = f'{text}\0{layer}\0{key}\0{mode}\0{coefficient:.8g}'.encode('utf-8')
         return int.from_bytes(hashlib.sha256(payload).digest()[:4], 'big', signed=False)
 
+    @staticmethod
+    def _random_controls(delta: torch.Tensor, seed: int, count: int) -> list[torch.Tensor]:
+        if int(count) < 1:
+            raise ValueError('Random-control ensemble must contain at least one direction.')
+        return [
+            normalized_random_control(delta, seed=int(seed) + 104729 * idx)
+            for idx in range(int(count))
+        ]
+
+    @staticmethod
+    def _random_effect_summary(values: Sequence[float], target_effect: float) -> tuple[float, float, float, float]:
+        if not values:
+            raise ValueError('Random-control values must not be empty.')
+        tensor = torch.tensor([float(x) for x in values], dtype=torch.float64)
+        signed_mean = float(tensor.mean().item())
+        abs_mean = float(tensor.abs().mean().item())
+        std = float(tensor.std(unbiased=False).item())
+        empirical_p = float(
+            (1 + int((tensor.abs() >= abs(float(target_effect))).sum().item()))
+            / (len(values) + 1)
+        )
+        return signed_mean, abs_mean, std, empirical_p
+
+    @staticmethod
+    def _dict_cosine(a: dict[int, float], b: dict[int, float]) -> float:
+        if not a and not b:
+            return 1.0
+        if not a or not b:
+            return 0.0
+        dot = sum(float(value) * float(b.get(feature_id, 0.0)) for feature_id, value in a.items())
+        norm_a = math.sqrt(sum(float(value) ** 2 for value in a.values()))
+        norm_b = math.sqrt(sum(float(value) ** 2 for value in b.values()))
+        if norm_a == 0.0 or norm_b == 0.0:
+            return 0.0
+        return float(dot / (norm_a * norm_b))
+
+    @staticmethod
+    def _dict_jaccard(a: dict[int, float], b: dict[int, float]) -> float:
+        set_a = {feature_id for feature_id, value in a.items() if float(value) > 0}
+        set_b = {feature_id for feature_id, value in b.items() if float(value) > 0}
+        union = set_a | set_b
+        return float(len(set_a & set_b) / len(union)) if union else 1.0
+
+    @staticmethod
+    def _max_pool_encoding(encoding: SparseEncoding) -> dict[int, float]:
+        indices = encoding.indices.detach().cpu()
+        values = encoding.values.detach().float().cpu()
+        if indices.ndim == 1:
+            indices = indices.unsqueeze(0)
+            values = values.unsqueeze(0)
+        pooled: dict[int, float] = {}
+        for row_ids, row_values in zip(indices.tolist(), values.tolist(), strict=True):
+            for feature_id, value in zip(row_ids, row_values, strict=True):
+                value = float(value)
+                if value <= 0:
+                    continue
+                feature_id = int(feature_id)
+                pooled[feature_id] = max(pooled.get(feature_id, 0.0), value)
+        return pooled
+
     @staticmethod
     def _encoding_map(encoding: SparseEncoding) -> dict[int, float]:
         return {
@@ -366,7 +474,13 @@ class FeatureLensRuntime:
         }
 
     @torch.inference_mode()
-    def analyze(self, text: str, layer: int, token_index: int = -1, top_n: int = 12) -> AnalysisResult:
+    def _analyze_and_pool(
+        self,
+        text: str,
+        layer: int,
+        token_index: int = -1,
+        top_n: int = 12,
+    ) -> tuple[AnalysisResult, dict[int, float]]:
         self.ensure_ready(preload_saes=False)
         assert self.model is not None and self.tokenizer is not None and self.sae_store is not None
         if int(layer) not in self.settings.layers:
@@ -377,9 +491,13 @@ class FeatureLensRuntime:
             self.model(**inputs, use_cache=False)
         hidden = bucket['hidden'][0]
         idx = self._resolve_index(int(token_index), hidden.shape[0])
-        residual = hidden[idx]
         sae = self.sae_store.get(int(layer))
-        encoding = sae.encode(residual)
+        all_encoding = sae.encode(hidden)
+        encoding = SparseEncoding(
+            indices=all_encoding.indices[idx],
+            values=all_encoding.values[idx],
+        )
+        residual = hidden[idx]
         reconstruction = sae.decode_sparse(encoding)
         metrics = reconstruction_metrics(residual, reconstruction)
         metrics['active_features'] = float(encoding.active_count)
@@ -398,7 +516,7 @@ class FeatureLensRuntime:
             rows.append(
                 [rank + 1, feature_id, activation, self.catalog.hint(int(layer), feature_id)]
             )
-        return AnalysisResult(
+        result = AnalysisResult(
             tokens=tokens,
             token_index=idx,
             layer=int(layer),
@@ -406,6 +524,12 @@ class FeatureLensRuntime:
             rows=rows,
             metrics=metrics,
         )
+        return result, self._max_pool_encoding(all_encoding)
+
+    @torch.inference_mode()
+    def analyze(self, text: str, layer: int, token_index: int = -1, top_n: int = 12) -> AnalysisResult:
+        result, _ = self._analyze_and_pool(text, layer, token_index, top_n)
+        return result
 
     @torch.inference_mode()
     def layer_sweep(self, text: str, token_index: int = -1) -> LayerSweepResult:
@@ -529,76 +653,120 @@ class FeatureLensRuntime:
         sae = self.sae_store.get(int(layer))
 
         target_ids: list[int] = []
-        baseline_seq = baseline_mean = None
-        baseline_token_logps: list[float] = []
-        baseline_next_logits: torch.Tensor | None = None
         capture: dict = {}
+        single_baseline_logits: torch.Tensor
+        single_baseline_mean: float | None = None
 
         if target_text.strip():
             target_ids = self._target_ids(target_text)
-            full_inputs = self._append_target(prompt_inputs, target_ids)
+            scoring_inputs = self._append_target(prompt_inputs, target_ids)
             with self._capture_hook(int(layer), capture):
-                baseline_full = self.model(**full_inputs, use_cache=False)
-            baseline_next_logits = baseline_full.logits[0, prompt_len - 1]
-            baseline_seq, baseline_mean, baseline_token_logps = sequence_logprob_summary(
-                baseline_full.logits[0],
+                single_baseline_out = self.model(**scoring_inputs, use_cache=False)
+            single_baseline_logits = single_baseline_out.logits[0]
+            _, single_baseline_mean, _ = sequence_logprob_summary(
+                single_baseline_logits,
                 prompt_length=prompt_len,
                 target_ids=target_ids,
             )
         else:
+            scoring_inputs = prompt_inputs
             with self._capture_hook(int(layer), capture):
-                baseline_prompt = self.model(**prompt_inputs, use_cache=False)
-            baseline_next_logits = baseline_prompt.logits[0, -1]
+                single_baseline_out = self.model(**scoring_inputs, use_cache=False)
+            single_baseline_logits = single_baseline_out.logits[0]
 
         residual = capture['hidden'][0, idx]
         encoding = sae.encode(residual)
         original_activation = encoding.activation_for(int(feature_id))
         spec = InterventionSpec(mode=mode, coefficient=float(coefficient))
         delta = residual_delta(sae.decoder_direction(int(feature_id)), original_activation, spec)
-        control_delta = normalized_random_control(
-            delta,
-            seed=self._control_seed(
-                text,
-                int(layer),
-                str(int(feature_id)),
-                mode,
-                float(coefficient),
-            ),
+        seed = self._control_seed(
+            text, int(layer), str(int(feature_id)), mode, float(coefficient)
+        )
+        random_controls = self._random_controls(
+            delta, seed=seed, count=self.settings.live_random_controls
         )
 
-        modified_next_logits: torch.Tensor
-        random_next_logits: torch.Tensor
-        modified_seq = modified_mean = random_seq = random_mean = None
-        modified_token_logps: list[float] = []
-        random_token_logps: list[float] = []
+        zero = torch.zeros_like(delta)
+        all_deltas = torch.stack([zero, delta, *random_controls], dim=0)
+        repeated = self._repeat_inputs(scoring_inputs, all_deltas.shape[0])
+        with self._batch_delta_hook(int(layer), idx, all_deltas):
+            edited = self.model(**repeated, use_cache=False)
+
+        baseline_logits = edited.logits[0]
+        modified_logits = edited.logits[1]
+        random_logits = [edited.logits[row] for row in range(2, edited.logits.shape[0])]
+        next_idx = prompt_len - 1
+        baseline_next_logits = baseline_logits[next_idx]
+        modified_next_logits = modified_logits[next_idx]
+        random_next_logits = [row[next_idx] for row in random_logits]
+
+        execution_drift_js = js_divergence_from_logits(
+            single_baseline_logits[next_idx], baseline_next_logits
+        )
+        js = js_divergence_from_logits(baseline_next_logits, modified_next_logits)
+        random_js_values = [
+            js_divergence_from_logits(baseline_next_logits, logits)
+            for logits in random_next_logits
+        ]
+        random_js_mean, random_js_abs_mean, random_js_std, js_empirical_p = (
+            self._random_effect_summary(random_js_values, js)
+        )
+        # JS divergence is non-negative, so signed and absolute means are identical up to numerical noise.
+        random_js_reference = random_js_abs_mean
+        js_ratio = abs(js) / max(random_js_reference, 1e-12)
+
+        baseline_seq = baseline_mean = modified_seq = modified_mean = None
+        random_seq_mean = random_mean_signed = random_abs_mean = random_mean_std = None
+        sequence_delta = random_sequence_delta = mean_delta = specificity = target_p = None
+        target_rows: list[list[object]] = []
+        target_tokens: list[str] = []
+        bp = mp = rp = None
+        execution_drift_mean = None
 
         if target_ids:
-            full_inputs = self._append_target(prompt_inputs, target_ids)
-            repeated = self._repeat_inputs(full_inputs, 2)
-            deltas = torch.stack([delta, control_delta], dim=0)
-            with self._batch_delta_hook(int(layer), idx, deltas):
-                edited_full = self.model(**repeated, use_cache=False)
-            modified_logits_all = edited_full.logits[0]
-            random_logits_all = edited_full.logits[1]
-            modified_next_logits = modified_logits_all[prompt_len - 1]
-            random_next_logits = random_logits_all[prompt_len - 1]
+            baseline_seq, baseline_mean, baseline_token_logps = sequence_logprob_summary(
+                baseline_logits, prompt_length=prompt_len, target_ids=target_ids
+            )
             modified_seq, modified_mean, modified_token_logps = sequence_logprob_summary(
-                modified_logits_all,
-                prompt_length=prompt_len,
-                target_ids=target_ids,
+                modified_logits, prompt_length=prompt_len, target_ids=target_ids
             )
-            random_seq, random_mean, random_token_logps = sequence_logprob_summary(
-                random_logits_all,
-                prompt_length=prompt_len,
-                target_ids=target_ids,
+            random_summaries = [
+                sequence_logprob_summary(logits, prompt_length=prompt_len, target_ids=target_ids)
+                for logits in random_logits
+            ]
+            random_seqs = [item[0] for item in random_summaries]
+            random_means = [item[1] for item in random_summaries]
+            random_token_matrix = [item[2] for item in random_summaries]
+            random_token_mean = [
+                float(sum(row[token_pos] for row in random_token_matrix) / len(random_token_matrix))
+                for token_pos in range(len(target_ids))
+            ]
+            random_mean_deltas = [float(value - baseline_mean) for value in random_means]
+            random_seq_deltas = [float(value - baseline_seq) for value in random_seqs]
+            mean_delta = float(modified_mean - baseline_mean)
+            sequence_delta = float(modified_seq - baseline_seq)
+            random_mean_signed, random_abs_mean, random_mean_std, target_p = self._random_effect_summary(
+                random_mean_deltas, mean_delta
+            )
+            random_sequence_delta = float(sum(random_seq_deltas) / len(random_seq_deltas))
+            random_seq_mean = float(sum(random_seqs) / len(random_seqs))
+            specificity = abs(mean_delta) / max(random_abs_mean, 1e-12)
+            _, single_mean, _ = sequence_logprob_summary(
+                single_baseline_logits, prompt_length=prompt_len, target_ids=target_ids
+            )
+            execution_drift_mean = float(baseline_mean - single_mean)
+
+            p = torch.softmax(baseline_next_logits.float(), dim=-1)
+            q = torch.softmax(modified_next_logits.float(), dim=-1)
+            random_probs = [torch.softmax(logits.float(), dim=-1) for logits in random_next_logits]
+            first_id = int(target_ids[0])
+            bp = float(p[first_id].item())
+            mp = float(q[first_id].item())
+            rp = float(sum(prob[first_id].item() for prob in random_probs) / len(random_probs))
+            target_tokens = [self.tokenizer.decode([int(token_id)]) for token_id in target_ids]
+            target_rows = self._target_rows(
+                target_ids, baseline_token_logps, modified_token_logps, random_token_mean
             )
-        else:
-            with self._delta_hook(int(layer), idx, delta):
-                modified_prompt = self.model(**prompt_inputs, use_cache=False)
-            with self._delta_hook(int(layer), idx, control_delta):
-                random_prompt = self.model(**prompt_inputs, use_cache=False)
-            modified_next_logits = modified_prompt.logits[0, -1]
-            random_next_logits = random_prompt.logits[0, -1]
 
         generation_kwargs = {
             'max_new_tokens': min(int(max_new_tokens), self.settings.max_new_tokens),
@@ -610,44 +778,11 @@ class FeatureLensRuntime:
         baseline_generation = self.model.generate(**prompt_inputs, **generation_kwargs)
         with self._delta_hook(int(layer), idx, delta):
             modified_generation = self.model.generate(**prompt_inputs, **generation_kwargs)
-
         baseline_ids = baseline_generation.sequences[0, prompt_len:]
         modified_ids = modified_generation.sequences[0, prompt_len:]
         baseline_text = self.tokenizer.decode(baseline_ids, skip_special_tokens=True)
         modified_text = self.tokenizer.decode(modified_ids, skip_special_tokens=True)
 
-        assert baseline_next_logits is not None
-        js = js_divergence_from_logits(baseline_next_logits, modified_next_logits)
-        random_js = js_divergence_from_logits(baseline_next_logits, random_next_logits)
-        js_ratio = abs(js) / max(abs(random_js), 1e-12)
-
-        bp = mp = rp = None
-        sequence_delta = random_sequence_delta = mean_delta = random_mean_delta = specificity = None
-        target_rows: list[list[object]] = []
-        target_tokens: list[str] = []
-        if target_ids:
-            p = torch.softmax(baseline_next_logits.float(), dim=-1)
-            q = torch.softmax(modified_next_logits.float(), dim=-1)
-            r = torch.softmax(random_next_logits.float(), dim=-1)
-            first_id = int(target_ids[0])
-            bp = float(p[first_id].item())
-            mp = float(q[first_id].item())
-            rp = float(r[first_id].item())
-            assert baseline_seq is not None and modified_seq is not None and random_seq is not None
-            assert baseline_mean is not None and modified_mean is not None and random_mean is not None
-            sequence_delta = float(modified_seq - baseline_seq)
-            random_sequence_delta = float(random_seq - baseline_seq)
-            mean_delta = float(modified_mean - baseline_mean)
-            random_mean_delta = float(random_mean - baseline_mean)
-            specificity = abs(mean_delta) / max(abs(random_mean_delta), 1e-12)
-            target_tokens = [self.tokenizer.decode([int(token_id)]) for token_id in target_ids]
-            target_rows = self._target_rows(
-                target_ids,
-                baseline_token_logps,
-                modified_token_logps,
-                random_token_logps,
-            )
-
         return InterventionResult(
             baseline_text=baseline_text,
             modified_text=modified_text,
@@ -655,8 +790,13 @@ class FeatureLensRuntime:
             delta_activation=float(spec.delta_activation(original_activation)),
             perturbation_norm=float(torch.linalg.vector_norm(delta.float()).item()),
             js_divergence=float(js),
-            random_js_divergence=float(random_js),
+            random_js_divergence=float(random_js_reference),
+            random_js_std=float(random_js_std),
             js_specificity_ratio=float(js_ratio),
+            js_empirical_p=float(js_empirical_p),
+            random_control_count=len(random_controls),
+            execution_drift_js=float(execution_drift_js),
+            execution_drift_mean_logprob=execution_drift_mean,
             target_text=target_text,
             target_token_count=len(target_ids),
             target_tokens=target_tokens,
@@ -665,18 +805,18 @@ class FeatureLensRuntime:
             random_target_prob=rp,
             baseline_sequence_logprob=baseline_seq,
             modified_sequence_logprob=modified_seq,
-            random_sequence_logprob=random_seq,
+            random_sequence_logprob=random_seq_mean,
             sequence_logprob_delta=sequence_delta,
             random_sequence_logprob_delta=random_sequence_delta,
             mean_logprob_delta=mean_delta,
-            random_mean_logprob_delta=random_mean_delta,
+            random_mean_logprob_delta=random_mean_signed,
+            random_abs_mean_logprob_delta=random_abs_mean,
+            random_mean_logprob_std=random_mean_std,
             target_specificity_ratio=specificity,
+            target_empirical_p=target_p,
             target_token_rows=target_rows,
             top_token_rows=self._top_token_rows(
-                self.tokenizer,
-                baseline_next_logits,
-                modified_next_logits,
-                k=8,
+                self.tokenizer, baseline_next_logits, modified_next_logits, k=8
             ),
         )
 
@@ -692,6 +832,8 @@ class FeatureLensRuntime:
     ) -> DoseResponseResult:
         if not target_text.strip():
             raise ValueError('Dose-response requires a target continuation.')
+        if not any(abs(float(multiplier) - 1.0) < 1e-12 for multiplier in multipliers):
+            raise ValueError('Dose-response multipliers must include 1.0 as the zero-edit reference.')
         self.ensure_ready(preload_saes=False)
         assert self.model is not None and self.tokenizer is not None and self.sae_store is not None
         prompt_inputs = self._inputs(text)
@@ -703,22 +845,19 @@ class FeatureLensRuntime:
 
         capture: dict = {}
         with self._capture_hook(int(layer), capture):
-            baseline_out = self.model(**full_inputs, use_cache=False)
-        baseline_logits = baseline_out.logits[0]
-        baseline_next = baseline_logits[prompt_len - 1]
-        baseline_seq, baseline_mean, _ = sequence_logprob_summary(
-            baseline_logits,
-            prompt_length=prompt_len,
-            target_ids=target_ids,
+            single_baseline_out = self.model(**full_inputs, use_cache=False)
+        single_baseline_logits = single_baseline_out.logits[0]
+        _, single_baseline_mean, _ = sequence_logprob_summary(
+            single_baseline_logits, prompt_length=prompt_len, target_ids=target_ids
         )
         residual = capture['hidden'][0, idx]
         encoding = sae.encode(residual)
         original_activation = encoding.activation_for(int(feature_id))
         direction = sae.decoder_direction(int(feature_id))
 
-        deltas = []
-        delta_coefficients = []
-        norms = []
+        deltas: list[torch.Tensor] = []
+        delta_coefficients: list[float] = []
+        norms: list[float] = []
         for multiplier in multipliers:
             spec = InterventionSpec('scale', float(multiplier))
             delta = residual_delta(direction, original_activation, spec)
@@ -730,13 +869,24 @@ class FeatureLensRuntime:
         with self._batch_delta_hook(int(layer), idx, torch.stack(deltas, dim=0)):
             outputs = self.model(**repeated, use_cache=False)
 
+        reference_idx = next(
+            idx for idx, multiplier in enumerate(multipliers) if abs(float(multiplier) - 1.0) < 1e-12
+        )
+        reference_logits = outputs.logits[reference_idx]
+        baseline_seq, baseline_mean, _ = sequence_logprob_summary(
+            reference_logits, prompt_length=prompt_len, target_ids=target_ids
+        )
+        baseline_next = reference_logits[prompt_len - 1]
+        execution_drift_mean = float(baseline_mean - single_baseline_mean)
+        execution_drift_js = js_divergence_from_logits(
+            single_baseline_logits[prompt_len - 1], baseline_next
+        )
+
         rows: list[list[object]] = []
         for row_idx, multiplier in enumerate(multipliers):
             modified_logits = outputs.logits[row_idx]
             modified_seq, modified_mean, _ = sequence_logprob_summary(
-                modified_logits,
-                prompt_length=prompt_len,
-                target_ids=target_ids,
+                modified_logits, prompt_length=prompt_len, target_ids=target_ids
             )
             rows.append(
                 [
@@ -747,17 +897,14 @@ class FeatureLensRuntime:
                     float(modified_mean),
                     float(modified_mean - baseline_mean),
                     float(modified_seq - baseline_seq),
-                    float(
-                        js_divergence_from_logits(
-                            baseline_next,
-                            modified_logits[prompt_len - 1],
-                        )
-                    ),
+                    float(js_divergence_from_logits(baseline_next, modified_logits[prompt_len - 1])),
                 ]
             )
         return DoseResponseResult(
             feature_activation=float(original_activation),
             target_tokens=[self.tokenizer.decode([int(token_id)]) for token_id in target_ids],
+            execution_drift_mean_logprob=execution_drift_mean,
+            execution_drift_js=float(execution_drift_js),
             rows=rows,
         )
 
@@ -793,51 +940,70 @@ class FeatureLensRuntime:
 
         capture: dict = {}
         with self._capture_hook(int(layer), capture):
-            baseline_out = self.model(**full_inputs, use_cache=False)
+            single_baseline_out = self.model(**full_inputs, use_cache=False)
+        single_baseline_logits = single_baseline_out.logits[0]
+        _, single_baseline_mean, _ = sequence_logprob_summary(
+            single_baseline_logits, prompt_length=prompt_len, target_ids=target_ids
+        )
         residual = capture['hidden'][0, idx]
         encoding = sae.encode(residual)
         activations = [encoding.activation_for(feature_id) for feature_id in ids]
         directions = torch.stack([sae.decoder_direction(feature_id) for feature_id in ids], dim=0)
         spec = InterventionSpec(mode, float(coefficient))
         delta, coefficient_deltas = joint_residual_delta(directions, activations, spec)
-        control = normalized_random_control(
-            delta,
-            seed=self._control_seed(
-                text,
-                int(layer),
-                ','.join(str(x) for x in ids),
-                mode,
-                float(coefficient),
-            ),
+        seed = self._control_seed(
+            text, int(layer), ','.join(str(x) for x in ids), mode, float(coefficient)
+        )
+        controls = self._random_controls(
+            delta, seed=seed, count=self.settings.live_random_controls
         )
 
-        repeated = self._repeat_inputs(full_inputs, 2)
-        with self._batch_delta_hook(int(layer), idx, torch.stack([delta, control], dim=0)):
+        zero = torch.zeros_like(delta)
+        all_deltas = torch.stack([zero, delta, *controls], dim=0)
+        repeated = self._repeat_inputs(full_inputs, all_deltas.shape[0])
+        with self._batch_delta_hook(int(layer), idx, all_deltas):
             outputs = self.model(**repeated, use_cache=False)
 
-        baseline_logits = baseline_out.logits[0]
-        modified_logits = outputs.logits[0]
-        random_logits = outputs.logits[1]
+        baseline_logits = outputs.logits[0]
+        modified_logits = outputs.logits[1]
+        random_logits = [outputs.logits[row] for row in range(2, outputs.logits.shape[0])]
         baseline_seq, baseline_mean, baseline_tokens = sequence_logprob_summary(
-            baseline_logits,
-            prompt_length=prompt_len,
-            target_ids=target_ids,
+            baseline_logits, prompt_length=prompt_len, target_ids=target_ids
         )
         modified_seq, modified_mean, modified_tokens = sequence_logprob_summary(
-            modified_logits,
-            prompt_length=prompt_len,
-            target_ids=target_ids,
-        )
-        random_seq, random_mean, random_tokens = sequence_logprob_summary(
-            random_logits,
-            prompt_length=prompt_len,
-            target_ids=target_ids,
+            modified_logits, prompt_length=prompt_len, target_ids=target_ids
         )
+        random_summaries = [
+            sequence_logprob_summary(logits, prompt_length=prompt_len, target_ids=target_ids)
+            for logits in random_logits
+        ]
+        random_seqs = [item[0] for item in random_summaries]
+        random_means = [item[1] for item in random_summaries]
+        random_token_matrix = [item[2] for item in random_summaries]
+        random_token_mean = [
+            float(sum(row[token_pos] for row in random_token_matrix) / len(random_token_matrix))
+            for token_pos in range(len(target_ids))
+        ]
         mean_delta = float(modified_mean - baseline_mean)
-        random_mean_delta = float(random_mean - baseline_mean)
+        sequence_delta = float(modified_seq - baseline_seq)
+        random_mean_deltas = [float(value - baseline_mean) for value in random_means]
+        random_seq_deltas = [float(value - baseline_seq) for value in random_seqs]
+        random_mean_signed, random_abs_mean, random_mean_std, target_p = self._random_effect_summary(
+            random_mean_deltas, mean_delta
+        )
         next_idx = prompt_len - 1
         js = js_divergence_from_logits(baseline_logits[next_idx], modified_logits[next_idx])
-        random_js = js_divergence_from_logits(baseline_logits[next_idx], random_logits[next_idx])
+        random_js_values = [
+            js_divergence_from_logits(baseline_logits[next_idx], logits[next_idx])
+            for logits in random_logits
+        ]
+        _, random_js_abs_mean, random_js_std, js_p = self._random_effect_summary(
+            random_js_values, js
+        )
+        execution_drift_mean = float(baseline_mean - single_baseline_mean)
+        execution_drift_js = js_divergence_from_logits(
+            single_baseline_logits[next_idx], baseline_logits[next_idx]
+        )
 
         feature_rows = [
             [
@@ -847,10 +1013,7 @@ class FeatureLensRuntime:
                 self.catalog.hint(int(layer), feature_id),
             ]
             for feature_id, activation, delta_coefficient in zip(
-                ids,
-                activations,
-                coefficient_deltas,
-                strict=True,
+                ids, activations, coefficient_deltas, strict=True
             )
         ]
         return FeatureSetResult(
@@ -858,22 +1021,27 @@ class FeatureLensRuntime:
             feature_rows=feature_rows,
             perturbation_norm=float(torch.linalg.vector_norm(delta.float()).item()),
             js_divergence=float(js),
-            random_js_divergence=float(random_js),
-            js_specificity_ratio=float(abs(js) / max(abs(random_js), 1e-12)),
+            random_js_divergence=float(random_js_abs_mean),
+            random_js_std=float(random_js_std),
+            js_specificity_ratio=float(abs(js) / max(random_js_abs_mean, 1e-12)),
+            js_empirical_p=float(js_p),
+            random_control_count=len(controls),
+            execution_drift_mean_logprob=execution_drift_mean,
+            execution_drift_js=float(execution_drift_js),
             baseline_sequence_logprob=float(baseline_seq),
             modified_sequence_logprob=float(modified_seq),
-            random_sequence_logprob=float(random_seq),
-            sequence_logprob_delta=float(modified_seq - baseline_seq),
-            random_sequence_logprob_delta=float(random_seq - baseline_seq),
+            random_sequence_logprob=float(sum(random_seqs) / len(random_seqs)),
+            sequence_logprob_delta=sequence_delta,
+            random_sequence_logprob_delta=float(sum(random_seq_deltas) / len(random_seq_deltas)),
             mean_logprob_delta=mean_delta,
-            random_mean_logprob_delta=random_mean_delta,
-            target_specificity_ratio=float(abs(mean_delta) / max(abs(random_mean_delta), 1e-12)),
+            random_mean_logprob_delta=random_mean_signed,
+            random_abs_mean_logprob_delta=random_abs_mean,
+            random_mean_logprob_std=float(random_mean_std),
+            target_specificity_ratio=float(abs(mean_delta) / max(random_abs_mean, 1e-12)),
+            target_empirical_p=float(target_p),
             target_tokens=[self.tokenizer.decode([int(token_id)]) for token_id in target_ids],
             target_token_rows=self._target_rows(
-                target_ids,
-                baseline_tokens,
-                modified_tokens,
-                random_tokens,
+                target_ids, baseline_tokens, modified_tokens, random_token_mean
             ),
         )
 
@@ -886,7 +1054,7 @@ class FeatureLensRuntime:
         target_text: str,
         sizes: Sequence[int] = (1, 3, 5),
     ) -> FeatureSetSweepResult:
-        """Jointly ablate the strongest k active features for k in ``sizes``."""
+        """Jointly ablate the strongest k active features and compare to random ensembles."""
         if not target_text.strip():
             raise ValueError('Feature-set size sweep requires a target continuation.')
         self.ensure_ready(preload_saes=False)
@@ -900,7 +1068,11 @@ class FeatureLensRuntime:
 
         capture: dict = {}
         with self._capture_hook(int(layer), capture):
-            baseline_out = self.model(**full_inputs, use_cache=False)
+            single_baseline_out = self.model(**full_inputs, use_cache=False)
+        single_baseline_logits = single_baseline_out.logits[0]
+        _, single_baseline_mean, _ = sequence_logprob_summary(
+            single_baseline_logits, prompt_length=prompt_len, target_ids=target_ids
+        )
         residual = capture['hidden'][0, idx]
         encoding = sae.encode(residual)
         active_ids = [
@@ -916,84 +1088,210 @@ class FeatureLensRuntime:
         if not valid_sizes:
             raise ValueError('Not enough active features for the requested set sizes.')
 
-        deltas: list[torch.Tensor] = []
-        controls: list[torch.Tensor] = []
-        feature_lists: list[list[int]] = []
-        norms: list[float] = []
+        condition_deltas: list[torch.Tensor] = [torch.zeros_like(residual)]
+        metadata: list[tuple[int, str, list[int], float]] = []
         for size in valid_sizes:
             selected = active_ids[:size]
             activations = [encoding.activation_for(feature_id) for feature_id in selected]
             directions = torch.stack([sae.decoder_direction(feature_id) for feature_id in selected])
             delta, _ = joint_residual_delta(
-                directions,
-                activations,
-                InterventionSpec('ablate', 0.0),
+                directions, activations, InterventionSpec('ablate', 0.0)
             )
-            control = normalized_random_control(
-                delta,
-                seed=self._control_seed(
-                    text,
-                    int(layer),
-                    f'top-{size}',
-                    'ablate_set',
-                    0.0,
-                ),
+            norm = float(torch.linalg.vector_norm(delta.float()).item())
+            condition_deltas.append(delta)
+            metadata.append((size, 'sae', selected, norm))
+            seed = self._control_seed(text, int(layer), f'top-{size}', 'ablate_set', 0.0)
+            controls = self._random_controls(
+                delta, seed=seed, count=self.settings.live_random_controls
             )
-            deltas.append(delta)
-            controls.append(control)
-            feature_lists.append(selected)
-            norms.append(float(torch.linalg.vector_norm(delta.float()).item()))
+            for control_idx, control in enumerate(controls):
+                condition_deltas.append(control)
+                metadata.append((size, f'random_{control_idx}', selected, norm))
 
-        all_deltas = torch.stack([item for pair in zip(deltas, controls, strict=True) for item in pair])
+        all_deltas = torch.stack(condition_deltas, dim=0)
         repeated = self._repeat_inputs(full_inputs, all_deltas.shape[0])
         with self._batch_delta_hook(int(layer), idx, all_deltas):
             outputs = self.model(**repeated, use_cache=False)
 
-        baseline_logits = baseline_out.logits[0]
+        baseline_logits = outputs.logits[0]
         baseline_seq, baseline_mean, _ = sequence_logprob_summary(
-            baseline_logits,
-            prompt_length=prompt_len,
-            target_ids=target_ids,
+            baseline_logits, prompt_length=prompt_len, target_ids=target_ids
         )
         baseline_next = baseline_logits[prompt_len - 1]
+        execution_drift_mean = float(baseline_mean - single_baseline_mean)
+        execution_drift_js = js_divergence_from_logits(
+            single_baseline_logits[prompt_len - 1], baseline_next
+        )
+
+        grouped: dict[int, dict[str, object]] = {
+            size: {'features': active_ids[:size], 'norm': None, 'sae': None, 'random': []}
+            for size in valid_sizes
+        }
+        for output_idx, meta in enumerate(metadata, start=1):
+            size, kind, selected, norm = meta
+            logits = outputs.logits[output_idx]
+            seq_logp, mean_logp, _ = sequence_logprob_summary(
+                logits, prompt_length=prompt_len, target_ids=target_ids
+            )
+            item = {
+                'seq': float(seq_logp),
+                'mean': float(mean_logp),
+                'js': float(js_divergence_from_logits(baseline_next, logits[prompt_len - 1])),
+            }
+            grouped[size]['norm'] = norm
+            grouped[size]['features'] = selected
+            if kind == 'sae':
+                grouped[size]['sae'] = item
+            else:
+                grouped[size]['random'].append(item)
+
         rows: list[list[object]] = []
-        for sweep_idx, size in enumerate(valid_sizes):
-            sae_logits = outputs.logits[2 * sweep_idx]
-            random_logits = outputs.logits[2 * sweep_idx + 1]
-            sae_seq, sae_mean, _ = sequence_logprob_summary(
-                sae_logits,
-                prompt_length=prompt_len,
-                target_ids=target_ids,
+        for size in valid_sizes:
+            group = grouped[size]
+            sae_item = group['sae']
+            random_items = group['random']
+            assert isinstance(sae_item, dict)
+            assert isinstance(random_items, list) and random_items
+            sae_mean_delta = float(sae_item['mean'] - baseline_mean)
+            sae_seq_delta = float(sae_item['seq'] - baseline_seq)
+            random_mean_deltas = [float(item['mean'] - baseline_mean) for item in random_items]
+            random_js_values = [float(item['js']) for item in random_items]
+            random_signed, random_abs, random_std, target_p = self._random_effect_summary(
+                random_mean_deltas, sae_mean_delta
             )
-            random_seq, random_mean, _ = sequence_logprob_summary(
-                random_logits,
-                prompt_length=prompt_len,
-                target_ids=target_ids,
+            _, random_js_abs, random_js_std, js_p = self._random_effect_summary(
+                random_js_values, float(sae_item['js'])
             )
-            sae_delta = float(sae_mean - baseline_mean)
-            random_delta = float(random_mean - baseline_mean)
-            sae_js = js_divergence_from_logits(baseline_next, sae_logits[prompt_len - 1])
-            random_js = js_divergence_from_logits(baseline_next, random_logits[prompt_len - 1])
             rows.append(
                 [
                     int(size),
-                    ', '.join(str(x) for x in feature_lists[sweep_idx]),
-                    norms[sweep_idx],
+                    ', '.join(str(x) for x in group['features']),
+                    float(group['norm']),
                     float(baseline_mean),
-                    float(sae_mean),
-                    sae_delta,
-                    random_delta,
-                    float(abs(sae_delta) / max(abs(random_delta), 1e-12)),
-                    float(sae_seq - baseline_seq),
-                    float(sae_js),
-                    float(random_js),
+                    float(sae_item['mean']),
+                    sae_mean_delta,
+                    random_signed,
+                    random_abs,
+                    random_std,
+                    float(abs(sae_mean_delta) / max(random_abs, 1e-12)),
+                    float(target_p),
+                    sae_seq_delta,
+                    float(sae_item['js']),
+                    random_js_abs,
+                    random_js_std,
+                    float(js_p),
                 ]
             )
         return FeatureSetSweepResult(
             target_tokens=[self.tokenizer.decode([int(token_id)]) for token_id in target_ids],
+            random_control_count=self.settings.live_random_controls,
+            execution_drift_mean_logprob=execution_drift_mean,
+            execution_drift_js=float(execution_drift_js),
             rows=rows,
         )
 
+    @torch.inference_mode()
+    def feature_interaction_test(
+        self,
+        text: str,
+        layer: int,
+        token_index: int,
+        feature_ids: Sequence[int],
+        target_text: str,
+    ) -> FeatureInteractionResult:
+        """Compare individual ablations with their joint ablation to measure non-additivity."""
+        if not target_text.strip():
+            raise ValueError('Feature interaction testing requires a target continuation.')
+        ids = list(dict.fromkeys(int(x) for x in feature_ids))
+        if len(ids) < 2:
+            raise ValueError('Select at least two features for the interaction decomposition.')
+        if len(ids) > 5:
+            raise ValueError('Select at most five features for the live interaction decomposition.')
+        self.ensure_ready(preload_saes=False)
+        assert self.model is not None and self.tokenizer is not None and self.sae_store is not None
+        prompt_inputs = self._inputs(text)
+        prompt_len = int(prompt_inputs['input_ids'].shape[1])
+        idx = self._resolve_index(int(token_index), prompt_len)
+        target_ids = self._target_ids(target_text)
+        full_inputs = self._append_target(prompt_inputs, target_ids)
+        sae = self.sae_store.get(int(layer))
+
+        capture: dict = {}
+        with self._capture_hook(int(layer), capture):
+            single_baseline_out = self.model(**full_inputs, use_cache=False)
+        single_logits = single_baseline_out.logits[0]
+        _, single_mean, _ = sequence_logprob_summary(
+            single_logits, prompt_length=prompt_len, target_ids=target_ids
+        )
+        residual = capture['hidden'][0, idx]
+        encoding = sae.encode(residual)
+        activations = [encoding.activation_for(feature_id) for feature_id in ids]
+        directions = [sae.decoder_direction(feature_id) for feature_id in ids]
+        individual_deltas = [
+            residual_delta(direction, activation, InterventionSpec('ablate', 0.0))
+            for direction, activation in zip(directions, activations, strict=True)
+        ]
+        joint_delta = torch.stack(individual_deltas, dim=0).sum(dim=0)
+        all_deltas = torch.stack([torch.zeros_like(joint_delta), *individual_deltas, joint_delta], dim=0)
+        repeated = self._repeat_inputs(full_inputs, all_deltas.shape[0])
+        with self._batch_delta_hook(int(layer), idx, all_deltas):
+            outputs = self.model(**repeated, use_cache=False)
+
+        baseline_logits = outputs.logits[0]
+        baseline_seq, baseline_mean, _ = sequence_logprob_summary(
+            baseline_logits, prompt_length=prompt_len, target_ids=target_ids
+        )
+        baseline_next = baseline_logits[prompt_len - 1]
+        rows: list[list[object]] = []
+        individual_mean_deltas: list[float] = []
+        for feature_idx, feature_id in enumerate(ids, start=1):
+            logits = outputs.logits[feature_idx]
+            seq_logp, mean_logp, _ = sequence_logprob_summary(
+                logits, prompt_length=prompt_len, target_ids=target_ids
+            )
+            delta_mean = float(mean_logp - baseline_mean)
+            individual_mean_deltas.append(delta_mean)
+            rows.append(
+                [
+                    f'Feature {feature_id}',
+                    str(feature_id),
+                    float(activations[feature_idx - 1]),
+                    float(torch.linalg.vector_norm(individual_deltas[feature_idx - 1].float()).item()),
+                    delta_mean,
+                    float(seq_logp - baseline_seq),
+                    float(js_divergence_from_logits(baseline_next, logits[prompt_len - 1])),
+                ]
+            )
+        joint_logits = outputs.logits[len(ids) + 1]
+        joint_seq, joint_mean, _ = sequence_logprob_summary(
+            joint_logits, prompt_length=prompt_len, target_ids=target_ids
+        )
+        joint_mean_delta = float(joint_mean - baseline_mean)
+        rows.append(
+            [
+                'Joint ablation',
+                ', '.join(str(x) for x in ids),
+                float(sum(activations)),
+                float(torch.linalg.vector_norm(joint_delta.float()).item()),
+                joint_mean_delta,
+                float(joint_seq - baseline_seq),
+                float(js_divergence_from_logits(baseline_next, joint_logits[prompt_len - 1])),
+            ]
+        )
+        additive_expected = float(sum(individual_mean_deltas))
+        interaction_excess = float(joint_mean_delta - additive_expected)
+        scale = max(sum(abs(value) for value in individual_mean_deltas), 1e-12)
+        return FeatureInteractionResult(
+            feature_ids=ids,
+            target_tokens=[self.tokenizer.decode([int(token_id)]) for token_id in target_ids],
+            rows=rows,
+            additive_expected_mean_delta=additive_expected,
+            joint_mean_delta=joint_mean_delta,
+            interaction_excess_mean_delta=interaction_excess,
+            normalized_interaction=float(interaction_excess / scale),
+            execution_drift_mean_logprob=float(baseline_mean - single_mean),
+        )
+
     @torch.inference_mode()
     def compare_paraphrases(
         self,
@@ -1006,8 +1304,8 @@ class FeatureLensRuntime:
     ) -> ParaphraseResult:
         if not text_a.strip() or not text_b.strip():
             raise ValueError('Enter both the original prompt and a paraphrase.')
-        a = self.analyze(text_a, int(layer), int(token_index_a), max(int(top_n), 12))
-        b = self.analyze(text_b, int(layer), int(token_index_b), max(int(top_n), 12))
+        a, pooled_a = self._analyze_and_pool(text_a, int(layer), int(token_index_a), max(int(top_n), 12))
+        b, pooled_b = self._analyze_and_pool(text_b, int(layer), int(token_index_b), max(int(top_n), 12))
 
         map_a = self._encoding_map(a.features)
         map_b = self._encoding_map(b.features)
@@ -1016,11 +1314,10 @@ class FeatureLensRuntime:
         union = set_a | set_b
         jaccard = len(set_a & set_b) / len(union) if union else 1.0
         cosine = sparse_topk_cosine(
-            a.features.indices,
-            a.features.values,
-            b.features.indices,
-            b.features.values,
+            a.features.indices, a.features.values, b.features.indices, b.features.values
         )
+        promptwide_jaccard = self._dict_jaccard(pooled_a, pooled_b)
+        promptwide_cosine = self._dict_cosine(pooled_a, pooled_b)
 
         top_ids_a = [int(row[1]) for row in a.rows[: int(top_n)]]
         top_ids_b = [int(row[1]) for row in b.rows[: int(top_n)]]
@@ -1033,13 +1330,7 @@ class FeatureLensRuntime:
             vb = float(map_b.get(feature_id, 0.0))
             status = 'shared' if va > 0 and vb > 0 else ('original only' if va > 0 else 'paraphrase only')
             rows.append(
-                [
-                    feature_id,
-                    va,
-                    vb,
-                    status,
-                    self.catalog.hint(int(layer), feature_id),
-                ]
+                [feature_id, va, vb, status, self.catalog.hint(int(layer), feature_id)]
             )
             chart_rows.append([str(feature_id), 'Original', va])
             chart_rows.append([str(feature_id), 'Paraphrase', vb])
@@ -1052,12 +1343,103 @@ class FeatureLensRuntime:
             token_index_b=b.token_index,
             topk_jaccard=float(jaccard),
             sparse_cosine=float(cosine),
+            promptwide_jaccard=float(promptwide_jaccard),
+            promptwide_cosine=float(promptwide_cosine),
             shared_top_n=int(shared_top_n),
             top_n=int(top_n),
             rows=rows,
             chart_rows=chart_rows,
         )
 
+    def _contrast_prompt_rows(self, prompts_per_concept: int) -> list[dict]:
+        data_path = Path(__file__).resolve().parents[1] / 'data' / 'prompts.jsonl'
+        rows = [
+            json.loads(line)
+            for line in data_path.read_text(encoding='utf-8').splitlines()
+            if line.strip()
+        ]
+        selected: list[dict] = []
+        by_concept: dict[str, list[dict]] = {}
+        for row in rows:
+            # Use one wording per paraphrase pair so the live contrast is not dominated by near-duplicates.
+            if int(row.get('variant', 0)) != 0:
+                continue
+            by_concept.setdefault(str(row['concept']), []).append(row)
+        for concept in sorted(by_concept):
+            selected.extend(by_concept[concept][: int(prompts_per_concept)])
+        return selected
+
+    @torch.inference_mode()
+    def concept_contrast_scan(
+        self,
+        feature_id: int,
+        layer: int,
+        prompts_per_concept: int | None = None,
+    ) -> ConceptContrastResult:
+        """Measure one SAE feature across a small balanced concept contrast batch."""
+        self.ensure_ready(preload_saes=False)
+        assert self.model is not None and self.tokenizer is not None and self.sae_store is not None
+        n = int(prompts_per_concept or self.settings.contrast_prompts_per_concept)
+        if n < 1 or n > 8:
+            raise ValueError('Contrast prompts per concept must be between 1 and 8.')
+        rows = self._contrast_prompt_rows(n)
+        if not rows:
+            raise RuntimeError('No controlled contrast prompts are available.')
+        texts = [str(row['text']) for row in rows]
+        batch = self.tokenizer(
+            texts,
+            return_tensors='pt',
+            padding=True,
+            truncation=True,
+            max_length=self.settings.max_prompt_tokens,
+        )
+        batch = {key: value.to(self.device) for key, value in batch.items()}
+        capture: dict = {}
+        with self._capture_hook(int(layer), capture):
+            self.model(**batch, use_cache=False)
+        # Left padding means the last position is the final real token for every prompt.
+        residuals = capture['hidden'][:, -1, :]
+        sae = self.sae_store.get(int(layer))
+        encoding = sae.encode(residuals)
+        mask = encoding.indices == int(feature_id)
+        activations = torch.where(mask, encoding.values, torch.zeros_like(encoding.values)).sum(dim=-1)
+        values = activations.detach().float().cpu().tolist()
+
+        grouped: dict[str, list[float]] = {}
+        for row, value in zip(rows, values, strict=True):
+            grouped.setdefault(str(row['concept']), []).append(float(value))
+        table_rows: list[list[object]] = []
+        for concept in sorted(grouped):
+            vals = grouped[concept]
+            tensor = torch.tensor(vals, dtype=torch.float64)
+            active = [value for value in vals if value > 0]
+            median = float(torch.median(tensor).item())
+            table_rows.append(
+                [
+                    concept,
+                    len(vals),
+                    float(tensor.mean().item()),
+                    median,
+                    float(len(active) / len(vals)),
+                    float(max(vals) if vals else 0.0),
+                ]
+            )
+        table_rows.sort(key=lambda row: (float(row[2]), float(row[4])), reverse=True)
+        leader = str(table_rows[0][0])
+        first = float(table_rows[0][2])
+        second = float(table_rows[1][2]) if len(table_rows) > 1 else 0.0
+        ratio = first / max(second, 1e-12) if first > 0 else 0.0
+        chart_rows = [[str(row[0]), float(row[2])] for row in table_rows]
+        return ConceptContrastResult(
+            feature_id=int(feature_id),
+            layer=int(layer),
+            prompts_per_concept=n,
+            rows=table_rows,
+            chart_rows=chart_rows,
+            leading_concept=leader,
+            leading_ratio=float(ratio),
+        )
+
 
 RUNTIME = FeatureLensRuntime()
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "featurelens"
-version = "0.3.0"
+version = "0.4.0"
 description = "Causal sparse-feature interpretability workbench for Qwen3 and Qwen-Scope SAEs"
 requires-python = ">=3.10"
 

research_config.json

@@ -62,6 +62,20 @@
     "scale"
   ],
   "feature_set_negative_control": "norm-matched random residual direction",
-  "dose_response_execution": "batched residual edits in one model forward after baseline",
-  "feature_set_sweep_execution": "all SAE and random-control residual edits batched in one model forward after baseline"
+  "dose_response_execution": "all scale conditions share the 1x batched no-edit reference",
+  "feature_set_sweep_execution": "zero-edit reference + SAE edits + random-control ensembles evaluated in one batched forward",
+  "live_random_controls": 8,
+  "offline_random_controls_default": 8,
+  "control_reference": "batched zero-edit residual row",
+  "paraphrase_promptwide_pooling": "max activation per SAE feature across all prompt tokens",
+  "live_features_v0_4": [
+    "batch_context_null_reference",
+    "random_control_ensemble",
+    "individual_vs_joint_interaction_decomposition",
+    "promptwide_paraphrase_robustness",
+    "controlled_concept_contrast_scan",
+    "copy_tables_with_headers"
+  ],
+  "concept_contrast_prompts_per_concept": 4,
+  "interaction_feature_limit": 5
 }

scripts/release_check.py

@@ -77,22 +77,28 @@ def check_config(config: dict) -> None:
         'sae_width': 32768,
         'dose_response_multipliers': [0.0, 0.5, 1.0, 1.5, 2.0, 3.0],
         'feature_set_sizes': [1, 3, 5],
+        'live_random_controls': 8,
+        'offline_random_controls_default': 8,
+        'concept_contrast_prompts_per_concept': 4,
+        'interaction_feature_limit': 5,
     }
     for key, value in expected.items():
         if config.get(key) != value:
             raise SystemExit(f'Unexpected {key}: {config.get(key)!r}. Expected {value!r}.')
 
-    required_live = {
-        'full_continuation_scoring',
-        'joint_multi_feature_intervention',
-        'topk_feature_set_size_sweep',
-        'paraphrase_robustness_explorer',
+    required_live_v04 = {
+        'batch_context_null_reference',
+        'random_control_ensemble',
+        'individual_vs_joint_interaction_decomposition',
+        'promptwide_paraphrase_robustness',
+        'controlled_concept_contrast_scan',
+        'copy_tables_with_headers',
     }
-    actual_live = set(config.get('live_features_v0_3', []))
-    if actual_live != required_live:
+    actual_live_v04 = set(config.get('live_features_v0_4', []))
+    if actual_live_v04 != required_live_v04:
         raise SystemExit(
-            'research_config.json live_features_v0_3 mismatch: '
-            f'{sorted(actual_live)}'
+            'research_config.json live_features_v0_4 mismatch: '
+            f'{sorted(actual_live_v04)}'
         )
 
 
@@ -151,17 +157,20 @@ def check_readme() -> None:
         'full-continuation',
         'feature-set',
         'paraphrase',
-        'norm-matched',
+        'random ensemble',
+        'batched zero-edit',
+        'concept contrast',
+        'non-additivity',
     ]
     missing = [value for value in required_strings if value.lower() not in readme.lower()]
     if missing:
-        raise SystemExit(f'README.md is missing required v0.3 content: {missing}')
+        raise SystemExit(f'README.md is missing required v0.4 content: {missing}')
 
 
 def check_pyproject() -> None:
     text = (ROOT / 'pyproject.toml').read_text(encoding='utf-8')
-    if 'version = "0.3.0"' not in text:
-        raise SystemExit('pyproject.toml must declare version 0.3.0.')
+    if 'version = "0.4.0"' not in text:
+        raise SystemExit('pyproject.toml must declare version 0.4.0.')
 
 
 def main() -> None:
@@ -178,7 +187,8 @@ def main() -> None:
     print(f'  causal tasks: {len(causal)}')
     print(f'  layers: {config["layers"]}')
     print(f'  feature-set sizes: {config["feature_set_sizes"]}')
-    print('  release: v0.3.0')
+    print(f'  random controls: {config["live_random_controls"]}')
+    print('  release: v0.4.0')
 
 
 if __name__ == '__main__':

tests/test_report_controls.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import math
+
+import pandas as pd
+
+from experiments.make_report import _paired_stats
+
+
+def test_paired_stats_uses_random_control_ensemble_mean_absolute_effect() -> None:
+    frame = pd.DataFrame(
+        [
+            {'task_id': 'a', 'intervention': 'ablate', 'condition': 'sae_feature', 'target_mean_logprob_delta': 0.30},
+            {'task_id': 'a', 'intervention': 'ablate', 'condition': 'random_norm_matched', 'target_mean_logprob_delta': 0.10},
+            {'task_id': 'a', 'intervention': 'ablate', 'condition': 'random_norm_matched', 'target_mean_logprob_delta': -0.20},
+            {'task_id': 'b', 'intervention': 'ablate', 'condition': 'sae_feature', 'target_mean_logprob_delta': -0.40},
+            {'task_id': 'b', 'intervention': 'ablate', 'condition': 'random_norm_matched', 'target_mean_logprob_delta': 0.05},
+            {'task_id': 'b', 'intervention': 'ablate', 'condition': 'random_norm_matched', 'target_mean_logprob_delta': -0.15},
+        ]
+    )
+    stats = _paired_stats(
+        frame,
+        index=['task_id', 'intervention'],
+        sae_condition='sae_feature',
+        random_condition='random_norm_matched',
+        seed=7,
+    )
+    # Per-task random absolute means are 0.15 and 0.10 -> overall 0.125.
+    assert math.isclose(float(stats['random_abs']), 0.125, rel_tol=1e-9)
+    assert math.isclose(float(stats['sae_abs']), 0.35, rel_tol=1e-9)
+    assert int(stats['n_pairs']) == 2
+
+
+def test_paired_stats_ignores_missing_random_pairs() -> None:
+    frame = pd.DataFrame(
+        [
+            {'task_id': 'a', 'intervention': 'ablate', 'condition': 'sae_feature', 'target_mean_logprob_delta': 0.30},
+            {'task_id': 'a', 'intervention': 'ablate', 'condition': 'random_norm_matched', 'target_mean_logprob_delta': 0.10},
+            {'task_id': 'b', 'intervention': 'ablate', 'condition': 'sae_feature', 'target_mean_logprob_delta': 0.90},
+        ]
+    )
+    stats = _paired_stats(
+        frame,
+        index=['task_id', 'intervention'],
+        sae_condition='sae_feature',
+        random_condition='random_norm_matched',
+        seed=8,
+    )
+    assert int(stats['n_pairs']) == 1
+    assert math.isclose(float(stats['sae_abs']), 0.30, rel_tol=1e-9)