Release FeatureLens v0.15.0

.gitignore

@@ -11,4 +11,4 @@ artifacts/*.npz
 *.pt
 *.safetensors
 pycache/
-venv/
+artifacts/*.complete

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v0.15.0
+
+- Reworked the public Gradio surface around a documented **research-instrument design system** rather than SaaS/dashboard defaults.
+- Added `DESIGN.md` with typography, color, spacing, surface, button, table, plot, and anti-pattern rules so future UI edits have explicit constraints.
+- Replaced the three-column onboarding/card pattern with compact editorial guidance; flattened repeated context/callout treatment; removed visible release marketing; shortened result copy so measured values lead and methodology lives in the Method tab/docs.
+- Introduced a two-typeface hierarchy (serif display headings, neutral sans-serif controls/data), tighter semantic spacing, compact primary actions, quiet utility buttons, and stronger explicit table headings.
+- Normalized the dynamic cross-target plots to a restrained three-series palette instead of Vega's saturated categorical defaults.
+- Rewrote the public README around the research question, live tool, offline study, and reproducible workflow instead of a long release-history narrative.
+- Added a ready-to-run Google Colab notebook plus `docs/COLAB.md` for Drive-backed artifact persistence and resumable study execution.
+- Added `--activation-batch-size` / `--activation-max-length` to the full runner and task-level checkpoint/resume support inside causal and feature-set stages.
+- Added automated design-contract regression tests.
+
 ## v0.14.0
 
 - Transitioned the project from live-feature expansion toward the full offline empirical study.

DESIGN.md

@@ -0,0 +1,112 @@
+# FeatureLens design system
+
+FeatureLens is a research instrument. Its interface should help someone **operate** an experiment and **read** evidence; it is not a landing page, growth dashboard, or software-company product surface.
+
+## Visual direction
+
+The visual reference is a compact scientific workbench: editorial headings, neutral controls, dense but readable tables, restrained plots, and very little decorative chrome. The interface should feel designed by someone who expects to inspect numbers for a while.
+
+### Typography
+
+- Display / section headings: `Georgia`, `Cambria`, `Times New Roman`, serif fallback.
+- Body, controls, table cells: `Segoe UI`, `Helvetica Neue`, `Arial`, sans-serif fallback.
+- Monospace is reserved for token chips and literal identifiers where fixed-width text helps scanning.
+- Hierarchy comes from scale, weight, and spacing—not from badges, italics, all-caps kickers, or a different treatment for every subsection.
+- Long explanatory prose should stay near 70–80 characters per line even though the analytical canvas is wide.
+
+### Color roles
+
+- Accent: muted teal `#6F8984`.
+- Secondary series: umber `#8A735D`, red-grey `#8C6A67`, plum `#786F82`, stone `#82827E`, blue-grey `#687982`.
+- Neutrals come from Gradio's grey theme tokens so light and dark appearance remain usable.
+- Saturated default categorical chart colors should be avoided when a fixed series set is known.
+- No gradients, neon accents, glows, glass effects, or decorative beige/cream surfaces.
+
+### Geometry and surfaces
+
+- Radius: approximately 2 px. Controls may be slightly rounded but should never look pill-shaped.
+- No nested-card hierarchy. Groups exist for layout/state only and are visually flat.
+- Avoid drop shadows. The only shadow permitted is the temporary in-place focus mode for dense tables/plots.
+- Use rules, alignment, and whitespace instead of containers-within-containers.
+- Do not add left-border "accent cards" or side-tab callouts.
+
+### Spacing
+
+- Spacing is intentionally uneven by semantic role: related controls are tight; a new experiment has more separation.
+- Section headings should sit close to the controls/results they introduce.
+- Table titles use the otherwise-empty table toolbar band rather than consuming another row of vertical space.
+- Do not introduce uniform 16/24/32 px spacing everywhere simply because it is convenient.
+
+## Components
+
+### Header
+
+One title and one factual subtitle. Do not show version badges, status chips, marketing claims, or repository trivia in the live header.
+
+### Tabs
+
+Flat text navigation with one active underline. No tab pills or raised nav cards.
+
+### Buttons
+
+- Primary experiment action: compact muted-teal button.
+- Utility action (`Copy TSV`, candidate hand-off): quiet secondary button.
+- Button text should describe the action (`Rank candidates`, `Run intervention`) rather than generic calls to action (`Continue`, `Get started`).
+- Do not make every button full-width on desktop.
+
+### Forms
+
+Labels are literal and stable because validation instructions refer to them. Helper text is only included when the field's semantics are not obvious from the label.
+
+### Tables
+
+Tables are primary research objects, not decorative cards. Use explicit headings, normal-weight data, tabular numerals, bounded height, horizontal scrolling for genuinely wide schemas, and a quiet `Copy TSV` utility.
+
+### Plots
+
+Plots use a small, restrained palette and preserve their aspect ratio in focus mode. A plot should not expand to fill every available screen dimension. Export filenames should describe the figure rather than defaulting to `chart.png`.
+
+### Results copy
+
+Measured values first. Caveats should be local and short; long methodological qualification belongs in **Method** or the offline report. Avoid paragraphs that restate what the immediately adjacent table already shows.
+
+## Information architecture
+
+- **Guide** — how the evidence ladder works.
+- **Workbench** — inspect one residual location and intervene on one feature.
+- **Feature sets** — joint-feature interventions and geometry.
+- **Features** — discovery, triage, controlled comparison, target profiles, and feature diagnostics.
+- **Paraphrases** — robustness to rewording.
+- **Layers** — early/middle/late SAE trajectory.
+- **Study** — artifact-backed offline results only.
+- **Method** — formulas, control discipline, and interpretation boundaries.
+
+The global context line is the single source of truth for the current Workbench prompt/layer/token. Do not repeat separate context cards in each tab.
+
+## Anti-patterns
+
+Do not add any of the following without a specific functional reason:
+
+- card grids for simple prose;
+- cards nested inside cards;
+- status-chip or badge collections;
+- gradients, glassmorphism, glow, or oversized decorative backgrounds;
+- AI/SaaS language such as "unlock", "supercharge", "powerful", or "all-in-one";
+- eyebrow/kicker labels above ordinary headings;
+- tiny numbered or Roman-numeral section labels;
+- every section centered or symmetrically weighted;
+- the same font for headings, prose, code, and tabular data;
+- full-width primary buttons by default;
+- explanatory text that narrates a bug fix or implementation history;
+- visible release/version marketing in the public application.
+
+## Review checklist
+
+Before changing the public UI, check:
+
+1. Does the change improve operating or reading the research tool?
+2. Is it using an existing type, color, spacing, and button role?
+3. Can a border/card/help paragraph be removed without losing meaning?
+4. Does the result remain readable in dark and light appearance?
+5. Did we preserve exact field/button terminology used by validation docs?
+6. Did we avoid spending ZeroGPU quota merely to test an unchanged inference path?

README.md

@@ -11,297 +11,102 @@ pinned: false
 license: mit
 ---
 
-# FeatureLens — Causal Interpretability Workbench
+# FeatureLens
 
-> **v0.14:** an offline-study transition release: prompt-wide held-out SAE discovery, activation-resample stability, cross-concept association-vs-causality synthesis, a resume-safe study runner, and an artifact-backed public study dashboard.
+FeatureLens is a causal interpretability workbench for `Qwen/Qwen3-1.7B-Base` and the **Qwen-Scope residual-stream sparse autoencoders**. It is built around one question:
 
-**Research question:**
+> **Do sparse features that predict a concept also causally influence model behaviour?**
 
-> Do sparse features that predict a concept also causally influence model behaviour?
+The project keeps association and intervention evidence separate. A large SAE activation or strong held-out classifier is useful evidence about representation; a causal claim requires changing the residual stream and measuring downstream behaviour against controlled perturbations.
 
-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.
+## What the live app does
 
+FeatureLens loads SAEs for residual layers **4, 14, and 26** and supports:
 
-## Evidence ladder
+- token-level residual capture and TopK SAE feature inspection;
+- reconstruction cosine, NMSE, activation mass, and layer trajectories;
+- single-feature ablation, scaling, and decoder-direction injection;
+- exact full-continuation teacher-forced scoring;
+- next-token distribution shifts and deterministic generation comparison;
+- eight norm-matched random controls for live specificity checks;
+- scale dose-response curves;
+- contrastive continuation preference;
+- joint feature-set interventions, 1/3/5 set-size sweeps, non-additivity, and decoder geometry;
+- concept-guided candidate discovery with current-token causal readiness;
+- batched candidate triage and random-controlled candidate comparison;
+- token traces, completion-cue tests, cue × context tests, and controlled concept contrasts;
+- local and prompt-wide paraphrase robustness;
+- cross-target causal profiles and pairwise preference shifts.
 
-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 the representation survive rewording locally and prompt-wide?
-4. **Candidate discovery** — which features are more active for a chosen controlled concept than for the other groups?
-5. **Controlled contrast** — does a selected feature prefer one concept group in a balanced live mini-batch?
-6. **Cue sensitivity** — is a feature responding to a lexical/completion cue rather than the underlying concept?
-7. **Candidate causal specificity** — do shortlisted candidate ablations exceed their own norm-matched random perturbation ensembles?
-8. **Single-feature causality** — does ablation/scaling change downstream probability?
-9. **Dose-response** — does effect size vary coherently with feature coefficient?
-10. **Feature-set causality** — do small sparse subspaces matter more than one feature?
-11. **Non-additivity** — does a joint edit differ from the sum of individual effects?
-12. **Specificity** — are targeted effects larger than norm-matched random residual perturbations?
-13. **Contrastive specificity** — does an edit change preference between a desired and comparison continuation?
-14. **Geometry** — are selected SAE decoder directions aligned, orthogonal, or cancelling before downstream model non-linearity?
-15. **Discovery stability** — does a live candidate shortlist survive a split-half check inside the same activation batch?
-16. **Cross-target profile** — does a candidate ablation concentrate on one exact continuation or move several alternatives?
-17. **Controlled evidence patterns** — is random-normalized influence target-weighted, distribution-shift weighted, broad, or weak/mixed?
-15. **Association–causality concordance** — do features ranked highly by concept evidence also rank highly by downstream target effect or distribution shift?
+The interface is deliberately an analytical tool rather than an SAE label viewer. Feature ids remain unlabeled until there is empirical evidence for a concept association.
 
-A high AUROC, high paraphrase overlap, or a large activation is still correlational evidence. Causal evidence comes from downstream change under controlled intervention.
+## Intervention semantics
 
-## Causal baseline discipline
-
-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.
-
-FeatureLens 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. FeatureLens uses **8 deterministic norm-matched random directions**.
-
-For a targeted residual delta `Δh`, each control satisfies:
-
-```text
-||Δh_random||₂ = ||Δh_SAE||₂
-```
-
-The app 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.
-
-The live empirical probability is intentionally coarse with only eight controls. The offline benchmark aggregates across held-out tasks and control ensembles.
-
-## Live application
-
-### Workbench
-
-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 with its own feature id and target continuation;
-- in-place plot/table focus that preserves the original plot aspect ratio and page location.
-
-### Feature sets
-
-FeatureLens can jointly ablate or scale selected active features:
+For residual vector `h`, SAE coefficient `z_i`, decoder direction `d_i`, and multiplier `α`:
 
 ```text
-h' = h + Σᵢ Δzᵢ dᵢ
+ablate: h' = h - z_i d_i
+scale:   h' = h + (α - 1) z_i d_i
+inject:  h' = h + δ d_i
 ```
 
-The tab includes:
-
-- 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.
+FeatureLens applies the decoded **delta** to the original residual. It does not replace the residual with the full SAE reconstruction, so reconstruction error is not silently mixed into the intervention.
 
-For the interaction decomposition, FeatureLens compares:
-
-```text
-observed joint effect
-vs
-sum of individual feature effects
-```
+Batched causal experiments include a zero-edit condition in the same execution context. Random controls match the L2 norm of the SAE perturbation.
 
-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.
+## Offline study
 
-### Feature evidence
+The live app is exploratory. The offline study is the dataset-scale experiment.
 
-The **Feature evidence** tab supports a discovery-to-causality workflow:
+It uses **224 discovery prompts** arranged as 112 paraphrase pairs across seven controlled concepts, plus **28 separate causal tasks**. Concept evidence uses prompt-wide max-pooled SAE activations across non-padding tokens; final-token sparse activations are saved separately for local analyses.
 
-1. **Concept-guided candidate discovery** — choose one of the seven controlled concept groups and rank SAE features with Balanced selectivity, Causal-ready-at-current-token, or raw mean-difference evidence. The result is a candidate list, **not a semantic label**.
-2. **Batched causal candidate triage** — ablate up to eight discovered candidates in one scoring batch and rank their target effects before spending the full random-control ensemble on a selected feature.
-3. **Feature-token activation trace** — show exactly where a selected feature enters the SAE TopK support across every token of the current Workbench prompt.
-4. **Completion-cue sensitivity** — append controlled suffixes/cues to one prompt stem and measure the selected feature at the final token.
-5. **Cue × context specificity** — cross cues with unrelated stems; a strong tested **cue-dominant** pattern is reported explicitly when one cue activates across all tested contexts and off-cue conditions stay inactive.
-6. **Prompt-wide controlled concept contrast** — evaluate one selected feature on a small balanced batch from:
+The study produces:
 
-- code;
-- mathematics;
-- positive sentiment;
-- negative sentiment;
-- German language;
-- factual entities;
-- uncertainty.
+- train-only feature selection with held-out AUROC/F1;
+- a dense final-token residual linear-probe baseline;
+- paraphrase stability;
+- 128-resample candidate-selection sensitivity;
+- random-controlled single-feature causal results;
+- top-1/3/5 feature-set causal results;
+- cross-concept association-versus-causality synthesis;
+- uncertainty-aware report figures and a measured Markdown report.
 
-Each controlled prompt is summarized by the feature's **maximum activation across non-padding tokens**. Candidate discovery defaults to **Balanced selectivity** — `positive selectivity × target activation rate × log1p(target mean activation)` — so globally large but weakly selective coefficients do not dominate purely by scale. A **Raw mean difference** mode remains available for comparison. The discovery table also reports current-Workbench prompt/token activation so candidates can be separated from candidates that are immediately causal-testable at the selected location. The controlled contrast reports mean/median prompt-wide maxima, prompt activation rate, mean activation when active, and maximum activation by concept.
+Run the full pipeline with:
 
-Both tools are exploratory live evidence. They never overwrite `Offline concept hint`; the held-out offline AUROC/F1 benchmark remains the stronger feature/concept claim.
-
-### Contrastive continuation preference
-
-A probability increase for one target can reflect a broad distribution shift rather than selective behavioral control. FeatureLens includes a stricter live test with two exact continuations, A and B. FeatureLens scores both teacher-forced under the same SAE intervention and random-control ensemble, then reports the causal change in:
-
-```text
-log P(A) - log P(B)
+```bash
+python -m experiments.run_all --resume
 ```
 
-The app also reports a token-normalized preference shift, targeted/random magnitude ratio, and exploratory empirical tail probability. This lets the workbench distinguish **general distributional influence** from a more selective change in relative continuation preference.
-
-### Feature-set decoder geometry
-
-The Feature Sets tab can inspect 2–8 selected decoder directions without an additional generation experiment. It reports pairwise decoder cosine similarities and compares the L2 norm of the activation-weighted joint ablation with the root-sum-square norm expected for independent directions. A ratio below 1 indicates net geometric cancellation; above 1 indicates net alignment. This is a geometric diagnostic, not by itself evidence of downstream causal interaction.
-
-### Paraphrase robustness
-
-FeatureLens 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.
+On a memory-constrained GPU, activation collection can be tuned without changing the experiment definition:
 
-## Interface and navigation
-
-The interface is designed so a reviewer does not need prior mechanistic-interpretability vocabulary to find the controls:
-
-- a **Start here** tab explains the evidence workflow and glossary in plain language;
-- a persistent **Current Workbench context** banner states the active prompt, layer and token after inspection;
-- experiments that reuse that state explicitly say **Uses current Workbench context**;
-- single-feature causal, dose-response, contrastive-preference, feature-set and evidence panels expose their own editable feature selectors instead of silently borrowing a hidden value;
-- concept-guided discovery gives users a route to candidate features without knowing feature IDs in advance;
-- headings now follow a conventional descending hierarchy and table headers use the same readable base scale as the surrounding interface;
-- tables and plots use a bounded **focus mode** instead of stretching to the entire viewport; plot exports are renamed from the generic browser filename to descriptive `featurelens_*.png` names;
-- all action/copy buttons retain one muted-teal visual language and copy actions provide visible confirmation.
-
-The centered 1600 px research canvas, bounded result-table heights, dynamic resize observer and explicit bottom padding from v0.5 remain in place for Hugging Face's embedded Space layout.
-
-## Copy tables with headers
-
-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 Dataframe focus control is retained, while the custom copy action avoids relying on browser text selection and gives immediate visual confirmation when clipboard writing succeeds.
-
-## Reconstruction-preserving edits
-
-Let `h` be the original residual vector, `z_i` the SAE coefficient, and `d_i` the decoder direction.
-
-```text
-ablate:   h' = h - z_i d_i
-scale α:  h' = h + (α - 1) z_i d_i
-inject δ: h' = h + δ d_i
+```bash
+python -m experiments.run_all --resume --activation-batch-size 8
 ```
 
-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.
-
-## Full-continuation scoring
-
-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.
-
-It reports:
-
-- target sequence log probability;
-- mean target log probability per token;
-- per-token log probabilities;
-- targeted edit deltas;
-- random-ensemble comparison.
-
-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:
-
-- **224 discovery prompts**;
-- **112 paraphrase pairs**;
-- 7 controlled concepts;
-- **28 separate causal completion tasks**;
-- residual/SAE activation collection at layers 4, 14 and 26.
-
-The offline pipeline computes:
-
-- SAE reconstruction cosine / NMSE;
-- held-out feature/concept AUROC and F1;
-- paraphrase TopK Jaccard and sparse activation cosine;
-- dense residual multinomial linear-probe baselines;
-- selected-feature ablation and 2× amplification;
-- 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.
-
-Feature selection is performed using the **training split only**. Paraphrase pairs never cross the train/test boundary.
-
-## Run the offline study
-
-A CUDA machine is strongly recommended for activation collection and causal intervention stages. v0.14 changes the offline SAE concept representation to **prompt-wide max-pooled activation across all non-padding prompt tokens**. Final-token sparse activations are saved separately for local diagnostics; the dense residual linear probe remains a final-token baseline.
+After the expensive model stages exist, CPU-only analysis can be regenerated with:
 
 ```bash
-python -m venv .venv
-source .venv/bin/activate
-pip install -r requirements.txt
-python experiments/run_all.py
+python -m experiments.run_analysis_only
 ```
 
-For interruptible/preemptible GPU sessions, use:
+Artifact integrity is checked with:
 
 ```bash
-python experiments/run_all.py --resume
+python -m scripts.validate_artifacts
 ```
 
-Completed stages are skipped when their expected artifacts already exist. After the expensive model/SAE stages have completed, all CPU-only evaluation/report logic can be rerun without another inference pass:
+### Google Colab
 
-```bash
-python experiments/run_analysis_only.py
-```
+A ready-to-run notebook is included at [`notebooks/FeatureLens_Offline_Study_Colab.ipynb`](notebooks/FeatureLens_Offline_Study_Colab.ipynb). It mounts Google Drive for persistent artifacts, keeps the Hugging Face cache on the Colab VM, chooses a conservative activation batch from available VRAM, and runs the resumable pipeline.
 
-The full pipeline is:
+See [`docs/COLAB.md`](docs/COLAB.md) for the exact workflow.
 
-```text
-build_dataset
-→ collect_activations
-  ├─ prompt-wide SAE feature maxima
-  └─ final-token sparse features + final-token residuals
-→ evaluate_features
-  ├─ held-out AUROC/F1
-  ├─ dense residual linear probe
-  └─ prompt-wide paraphrase stability
-→ run_causal
-→ run_feature_sets
-→ analyze_stability
-  └─ 128 balanced activation resamples
-→ analyze_study
-  └─ association/stability ↔ random-normalized causal evidence
-→ make_report
-→ validate_artifacts
-```
+## Public artifacts
 
-Outputs are generated under `artifacts/`:
+Large activation caches are intentionally excluded from Git. The small measured outputs that can be committed after a real run include:
 
 ```text
 artifacts/
-├── activations/                     # large; keep gitignored
 ├── feature_catalog.csv
 ├── layer_metrics.csv
 ├── stability.csv
@@ -313,175 +118,66 @@ artifacts/
 ├── summary.json
 ├── report.md
 └── figures/
-    ├── feature_auroc.png
-    ├── layer_diagnostics.png
-    ├── causal_effects.png
-    ├── feature_set_effects.png
-    ├── association_vs_causality.png
-    └── candidate_stability.png
-```
-
-Validate the small public artifacts before committing them:
-
-```bash
-python -m scripts.validate_artifacts
-```
-
-`summary.json`, `study_summary.json`, and `report.md` are generated from measured artifacts. No scientific benchmark numbers are fabricated in the repository. The live **Offline study** tab automatically turns into a results dashboard once these small CSV/JSON/figure artifacts are committed.
-
-See [`docs/OFFLINE_STUDY.md`](docs/OFFLINE_STUDY.md) for the staged workflow and interpretation guardrails.
-
-## Hugging Face deployment
-
-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 variables:
-
-```text
-FEATURELENS_MODEL_ID=Qwen/Qwen3-1.7B-Base
-FEATURELENS_SAE_REPO=Qwen/SAE-Res-Qwen3-1.7B-Base-W32K-L0_50
-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
 ```
 
-## UI design
-
-The interface deliberately stays closer to a conventional research instrument than a rounded dashboard:
-
-- 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 app also installs a lightweight browser-side reflow observer for dynamic output-height changes. Hugging Face still owns the outer embedding frame, so the direct Space URL remains a useful diagnostic if embedded-page scrolling ever behaves differently.
+The **Study** tab reads these artifacts directly. Before the offline run is materialized it intentionally shows no placeholder metrics.
 
 ## Repository layout
 
 ```text
 FeatureLens/
-├── app.py
-├── featurelens/
-│   ├── config.py
-│   ├── sae.py
-│   ├── interventions.py
-│   ├── runtime.py
-│   ├── metrics.py
-│   ├── stats.py
-│   ├── selection.py
-│   ├── catalog.py
-│   └── study.py
-├── experiments/
-│   ├── build_dataset.py
-│   ├── collect_activations.py
-│   ├── evaluate_features.py
-│   ├── run_causal.py
-│   ├── run_feature_sets.py
-│   ├── analyze_stability.py
-│   ├── analyze_study.py
-│   ├── make_report.py
-│   ├── run_analysis_only.py
-│   └── run_all.py
-├── data/
-├── tests/
-├── scripts/
-│   ├── release_check.py
-│   ├── validate_artifacts.py
-│   └── ui_smoke.py
-├── docs/
-└── research_config.json
+├── app.py                    # Gradio / ZeroGPU workbench
+├── featurelens/              # SAE, runtime, metrics, interventions, study loader
+├── experiments/              # offline collection, evaluation, causal study, reports
+├── data/                     # controlled prompt and causal-task definitions
+├── artifacts/                # small public study outputs; activations are ignored
+├── notebooks/                # Colab runner
+├── scripts/                  # release, UI smoke, artifact validation
+├── tests/                    # software and methodology regression tests
+├── docs/                     # methodology, validation, deployment, Colab notes
+├── DESIGN.md                 # UI design contract
+└── research_config.json      # experiment configuration
 ```
 
-## v0.10 association-to-causality synthesis
-
-- **Discovery–causality alignment** joins the concept-discovery table with the batched ablation screen for the same shortlist.
-- **Three ranks are kept separate:** discovery evidence, target-continuation effect, and whole next-token distribution shift.
-- **Descriptive Spearman concordance** reports candidate-score correlation with absolute target effect and with next-token JS; small live screens are never presented as significance tests.
-- **Rank-shift diagnostics** make cases such as a discovery-rank #1 feature becoming target-effect rank #5 immediately visible.
-- **Association-vs-target-effect scatter** is generated from the same two existing GPU calls; the synthesis itself costs no additional GPU time.
-- Existing v0.9 causal-ready discovery, candidate triage, in-place focus, and GPU-budget-aware validation remain unchanged.
-
-## v0.11 controlled candidate specificity
-
-- **Controlled candidate specificity** compares up to three shortlisted SAE ablations against each candidate's own eight-direction norm-matched random ensemble in one shared batched execution context.
-- **Strategic shortlist selection** preserves the discovery leader, target-effect leader, and distribution-shift leader when they differ, then fills remaining slots by triage target rank. This avoids confirming only whichever metric already won.
-- **Two controlled causal notions remain separate:** target-specificity ratio normalizes the specified continuation effect; JS-specificity ratio normalizes whole next-token distribution shift.
-- **Association vs controlled causality** joins discovery score/rank to random-normalized target and JS specificity, with descriptive Spearman concordance and rank shifts.
-- The controlled live screen remains deliberately small: three candidates × eight controls each plus one zero-edit reference. Empirical tails are therefore coarse diagnostics rather than conventional significance tests.
-- The validated in-place focus behavior and unchanged paraphrase/trajectory/feature-set paths are not touched. HF acceptance for v0.11 requires only the new controlled-candidate GPU path.
-
-## v0.12 evidence synthesis and cross-target profiling
-
-v0.12 bundles several related improvements instead of adding one isolated widget:
-
-- **Split-half discovery stability** reuses the concept-discovery activation batch and compares candidate shortlists from two prompt halves. This adds no GPU inference and is explicitly a small-sample sensitivity diagnostic rather than a reliability estimate.
-- **Controlled evidence patterns** always summarize the random-normalized candidate table, separating broad controlled influence, target-weighted effects, distribution-shift-dominant effects, and weak/mixed specificity. These are effect-ratio descriptions, not significance labels.
-- **Association vs controlled causality** no longer fails silently when discovery state is absent after a Space rebuild. The UI explains that controlled evidence remains valid while discovery-rank alignment requires the discovery table from the current browser session.
-- **Cross-target causal profile** screens up to three candidate ablations across two to five exact continuations. It reports target-wise mean/sequence log-probability deltas, next-token JS, the strongest target per feature, and a target-profile ratio. This stage intentionally omits random controls; controlled candidate specificity remains the matched-random causal test.
-- HF validation remains GPU-budget-aware: rerun only the touched discovery path and the new cross-target path. Unchanged paraphrase, trajectory, set-size, dose-response, cue, and focus paths stay covered by automated tests.
-
-## v0.14 offline-study transition
-
-v0.14 deliberately stops expanding the live intervention surface and strengthens the empirical study behind it.
-
-- **Prompt-wide offline SAE evidence:** concept-feature discovery and paraphrase stability use each feature's maximum activation across all non-padding prompt tokens. This avoids treating an arbitrary final token as the semantic representation of an entire prompt. Final-token sparse activations remain available separately for local diagnostics.
-- **Activation-resample candidate selection stability:** `analyze_stability.py` performs 128 deterministic balanced resamples of the saved prompt-wide activations and records shortlist support plus median/mean resample rank. No model inference is repeated.
-- **Association vs random-normalized causality across concepts:** `analyze_study.py` joins held-out AUROC/F1, paraphrase stability, candidate resample support, causal active rate, target specificity, and JS specificity for the selected feature of every controlled concept. Cross-concept Spearman correlations are descriptive because there are only seven concepts.
-- **Artifact-backed Offline study tab:** the public app remains honest when no benchmark has been run, then automatically displays committed study tables and figures when real artifacts exist.
-- **Resume-safe full runner:** `python experiments/run_all.py --resume` skips completed stages; `python experiments/run_analysis_only.py` reruns only CPU evaluation/stability/report logic once expensive inference artifacts exist.
-- **Artifact schema validation:** `python -m scripts.validate_artifacts` checks that public study outputs are non-empty, prompt-wide v0.14 activations were used, and required causal/stability columns exist.
-
-## Validation
+## Local validation
 
 ```bash
-python -m ruff check app.py featurelens experiments tests scripts
-python -m pytest -q
-python -m compileall -q app.py featurelens experiments scripts
-python scripts/ui_smoke.py
-python scripts/release_check.py
+python3 -m pytest -q
+python3 -m compileall -q app.py featurelens experiments scripts
+python3 -m ruff check app.py featurelens experiments tests scripts
+python3 scripts/ui_smoke.py
+python3 scripts/release_check.py
 ```
 
-See [`docs/VALIDATION.md`](docs/VALIDATION.md). The v0.12 guide uses the **exact labels shown in the UI** and asks for only two touched/new HF paths: causal-ready discovery (to validate split-half stability) and the cross-target causal profile. Unchanged paraphrase, trajectory, feature-set, dose-response, cue, controlled-specificity, and focus paths are not rerun.
-
-## Limitations
-
-- SAE features are sparse directions, not guaranteed monosemantic concepts.
-- Live candidate discovery and concept contrast are small controlled diagnostics, not a universal ontology or semantic labeling system.
-- Completion-cue sensitivity diagnoses lexical/structural dependence but does not establish a feature's full semantics.
-- 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
+The UI smoke test performs a real local Gradio `launch()` rather than only constructing the component tree.
 
-> **FeatureLens — Causal Interpretability Workbench** | PyTorch, Qwen3, Sparse Autoencoders, Mechanistic Interpretability, Gradio
-> Built an SAE-based interpretability system for Qwen3-1.7B with held-out concept discovery, concept-guided candidate discovery, token/prompt-wide, completion-cue, and cue × context feature evidence, reconstruction-preserving single and multi-feature interventions, full-continuation and contrastive preference scoring, dose-response analysis, decoder-geometry/non-additivity diagnostics, discovery-to-causality rank analysis, multi-candidate random-controlled specificity screening, split-half/resample discovery stability, cross-target causal profiling, controlled evidence-pattern synthesis, prompt-wide held-out SAE evaluation, association-vs-random-normalized-causality study synthesis, and norm-matched random-control ensembles.
+## Methodology notes
 
-## Acknowledgements
+Several quantities answer different questions and should not be collapsed into one score:
 
-FeatureLens builds on the open Qwen3 model and Qwen-Scope residual-stream SAE checkpoints from the Qwen team.
+- **held-out AUROC/F1** — concept association;
+- **paraphrase / resample stability** — sensitivity to wording or sample choice;
+- **target Δ log p** — effect on one specified continuation;
+- **Jensen-Shannon divergence** — local distributional change;
+- **random-normalized specificity** — whether the targeted SAE edit exceeds an equal-norm residual perturbation baseline;
+- **feature-set non-additivity** — downstream interaction under joint edits;
+- **decoder geometry** — alignment/cancellation before downstream model non-linearity.
 
-## v0.13 stability and target-selectivity synthesis
+The full methodology is documented in [`docs/METHODOLOGY.md`](docs/METHODOLOGY.md) and the offline study protocol in [`docs/OFFLINE_STUDY.md`](docs/OFFLINE_STUDY.md).
 
-v0.13 deliberately adds **no new GPU callback**. It strengthens the two live paths already used in v0.12.
-
-### Resample shortlist support
-
-Concept-guided discovery still reports split-half Jaccard, but now also reranks the same already-computed controlled activations under **32 deterministic balanced bootstrap resamples**. Each displayed feature receives a **Resample shortlist support** fraction and **Median resample rank**. The summary reports the mean displayed support and how many candidates survive at least 75% of resampled shortlists. These are small-sample sensitivity diagnostics, not confidence intervals or held-out reliability claims.
+## Limitations
 
-### Cross-target effect concentration
+- Live ZeroGPU controls are intentionally small; eight-control empirical tails are coarse diagnostics.
+- SAE feature ids are layer-specific and should not be compared across layers by id.
+- Prompt-wide max pooling discards token order.
+- Dense linear probes and prompt-wide SAE features use different pooling schemes and are reported as separate baselines.
+- Cross-concept study correlations have only seven concepts and are descriptive.
+- A candidate feature can be predictive without being causally specific, and a causally disruptive feature need not selectively control the target one might infer from its association.
 
-The cross-target profile now separates a feature whose causal effect is concentrated on one exact continuation from one that broadly moves several alternatives. For each feature it reports **Normalized effect entropy**, **Effect concentration = 1 − entropy**, and **Signed bias = ΣΔ / Σ|Δ|**. A descriptive profile pattern labels cases such as target-concentrated/mixed-sign or broad same-sign suppression/enhancement; this label is a heuristic summary, not a semantic feature label.
+## Design
 
-### Pairwise target preference
+The public UI follows the project-specific design contract in [`DESIGN.md`](DESIGN.md): restrained typography and color, flat information hierarchy, minimal decorative chrome, compact actions, explicit table headings, and no marketing-style cards/badges/gradients.
 
-Every cross-target run also derives **pairwise target preference shifts** without another forward pass. For targets A and B, FeatureLens reports `Δ(A−B) = Δ mean log p/token(A) − Δ mean log p/token(B)`. Positive values mean the SAE ablation shifts token-normalized preference toward A relative to B. This turns the same cross-target scores into a more direct comparison of alternatives while keeping the random-controlled specificity experiment separate.
+## License
 
-See [`docs/VALIDATION.md`](docs/VALIDATION.md). v0.13 requires only the two touched GPU paths: causal-ready discovery and cross-target profiling.
+MIT. See [`LICENSE`](LICENSE).

app.py

@@ -9,25 +9,38 @@ from featurelens.runtime import RUNTIME
 from featurelens.study import OfflineStudy
 
 # 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"
+INK_TEAL = "#6F8984"
+INK_UMBER = "#8A735D"
+INK_RED = "#8C6A67"
+INK_PLUM = "#786F82"
+INK_STONE = "#82827E"
+INK_BLUEGREY = "#687982"
 
 STUDY = OfflineStudy()
 
 CSS = r"""
+/*
+FeatureLens UI system
+---------------------
+This is an analytical instrument, not a SaaS landing page. The interface uses
+plain surfaces, a restrained accent, strong typographic hierarchy, compact
+forms, and deliberate spacing instead of nested cards, badges, glow, or
+uniform full-width CTAs.
+*/
 .gradio-container {
-  width: min(96vw, 1600px) !important;
-  max-width: 1600px !important;
-  margin-left: auto !important;
-  margin-right: auto !important;
-  padding: 0 22px 128px !important;
-  font-family: "Times New Roman", Times, "Liberation Serif", Georgia, serif !important;
-  font-size: 16px !important;
-  line-height: 1.52;
+  --fl-accent: #6F8984;
+  --fl-accent-hover: #607A75;
+  --fl-rule: var(--border-color-primary);
+  --fl-body: "Segoe UI", "Helvetica Neue", Arial, sans-serif;
+  --fl-display: Georgia, Cambria, "Times New Roman", serif;
+  --fl-mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  width: min(95vw, 1500px) !important;
+  max-width: 1500px !important;
+  margin: 0 auto !important;
+  padding: 0 24px 112px !important;
+  font-family: var(--fl-body) !important;
+  font-size: 15.5px !important;
+  line-height: 1.48;
 }
 .gradio-container input,
 .gradio-container textarea,
@@ -36,152 +49,251 @@ CSS = r"""
 .gradio-container label,
 .gradio-container table,
 .gradio-container .prose {
-  font-family: "Times New Roman", Times, "Liberation Serif", Georgia, serif !important;
+  font-family: var(--fl-body) !important;
 }
-.gradio-container input,
-.gradio-container textarea,
-.gradio-container select { font-size: 15.5px !important; }
-.gradio-container table { font-size: 15.5px !important; }
-.gradio-container table thead th, .gradio-container [role="columnheader"] { font-size: 16px !important; font-weight: 700 !important; }
-.gradio-container table tbody td, .gradio-container [role="gridcell"] { font-size: 15.5px !important; }
-.gradio-container label, .gradio-container .label-wrap { font-size: 15px !important; }
-.gradio-container p, .gradio-container li { font-size: 16px; }
-.gradio-container h2 { font-size: 1.72rem; line-height: 1.25; }
-.gradio-container h3 { font-size: 1.46rem; line-height: 1.28; }
-.gradio-container h4 { font-size: 1.24rem; line-height: 1.30; }
+.gradio-container h1,
+.gradio-container h2,
+.gradio-container h3,
+.gradio-container h4,
+.gradio-container .section-rule,
+.gradio-container .table-heading,
+.gradio-container .hero-title {
+  font-family: var(--fl-display) !important;
+}
+.gradio-container p,
+.gradio-container li { font-size: 15.5px; }
+.gradio-container h2 { font-size: 1.68rem; line-height: 1.22; margin-bottom: .45rem; }
+.gradio-container h3 { font-size: 1.36rem; line-height: 1.26; margin-bottom: .4rem; }
+.gradio-container h4 { font-size: 1.14rem; line-height: 1.30; margin-bottom: .35rem; }
+
+/* Header: compact, editorial, no product-release chrome. */
 .hero {
-  padding: 14px 2px 10px;
-  border-bottom: 1px solid var(--border-color-primary);
-  margin-bottom: 14px;
+  padding: 18px 0 14px;
+  border-bottom: 1px solid var(--fl-rule);
+  margin-bottom: 10px;
 }
 .hero h1 {
   margin: 0;
-  font-size: 2.18rem;
+  font-family: var(--fl-display) !important;
+  font-size: 2rem;
   font-weight: 600;
-  letter-spacing: 0;
+  line-height: 1.05;
+  letter-spacing: -.015em;
+}
+.hero .subtitle {
+  margin-top: 6px;
+  max-width: 68ch;
+  font-size: .98rem;
+  color: var(--body-text-color-subdued);
+}
+
+/* Navigation is deliberately flat: text tabs + one active rule. */
+.gradio-container .tabs > .tab-nav,
+.gradio-container [role="tablist"] {
+  gap: 2px !important;
+  border-bottom: 1px solid var(--fl-rule) !important;
 }
-.hero .subtitle { margin-top: 4px; font-size: 1.08rem; opacity: .82; }
-.hero .question { margin-top: 6px; font-size: 1rem; opacity: .72; }
+.gradio-container [role="tab"] {
+  border-radius: 0 !important;
+  border: 0 !important;
+  background: transparent !important;
+  box-shadow: none !important;
+  font-weight: 500 !important;
+  padding: 9px 11px !important;
+}
+.gradio-container [role="tab"][aria-selected="true"] {
+  color: var(--body-text-color) !important;
+  border-bottom: 2px solid var(--fl-accent) !important;
+}
+
+/* Current context is a quiet status line, not a side-accent card. */
+.context-card {
+  border: 0 !important;
+  border-bottom: 1px solid var(--fl-rule) !important;
+  background: transparent !important;
+  padding: 8px 0 10px !important;
+  margin: 0 0 14px !important;
+  border-radius: 0 !important;
+  color: var(--body-text-color-subdued);
+}
+.context-card p { margin: 0 !important; font-size: .93rem !important; }
+
+/* Introductory prose stays narrow even when the analytical canvas is wide. */
+.guide-intro { max-width: 72ch; margin-bottom: 10px; }
+
+/* Section rhythm: no roman numerals, small-caps, or decorative top rules. */
 .section-rule {
-  margin: 20px 0 11px;
-  padding-top: 9px;
-  border-top: 1px solid var(--border-color-primary);
-  font-variant: small-caps;
-  letter-spacing: .045em;
-  font-size: 1.12rem;
-  font-weight: 700;
-  opacity: .88;
+  margin: 28px 0 6px;
+  padding: 0;
+  border: 0;
+  font-variant: normal;
+  letter-spacing: 0;
+  font-size: 1.34rem;
+  font-weight: 600;
+  opacity: 1;
 }
-.token-wrap { display: flex; flex-wrap: wrap; gap: 6px; padding: 8px 2px 14px; line-height: 1.9; }
-.token {
-  background: var(--background-fill-secondary);
-  border: 1px solid var(--border-color-primary);
-  border-radius: 2px;
-  padding: 3px 7px;
-  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace !important;
-  font-size: 12.5px;
+.section-note,
+.candidate-help,
+.form-note,
+.graph-note,
+.small-note {
+  max-width: 78ch;
+  color: var(--body-text-color-subdued) !important;
+  opacity: 1 !important;
+  font-size: .91rem !important;
 }
-.token.selected { border: 2px solid #708B86; font-weight: 700; }
-.token sup { opacity: .58; margin-right: 4px; }
-.small-note { opacity: .74; font-size: 14px; }
+.section-note { margin: 0 0 12px !important; }
+.form-note { margin: -2px 0 7px !important; }
+.candidate-help { margin-top: 2px !important; }
+
+/* Explanatory callouts use a plain rule instead of card / side-tab styling. */
 .instrument-note {
-  border: 1px solid var(--border-color-primary);
-  border-radius: 2px;
-  padding: 10px 12px;
-  background: var(--background-fill-secondary);
-  margin: 6px 0 11px;
+  border: 0 !important;
+  border-top: 1px solid var(--fl-rule) !important;
+  border-bottom: 1px solid var(--fl-rule) !important;
+  border-radius: 0 !important;
+  padding: 8px 0 !important;
+  background: transparent !important;
+  margin: 4px 0 12px !important;
+  color: var(--body-text-color-subdued);
+  font-size: .92rem;
+}
+
+/* Forms stay utilitarian and square-ish. */
+.gradio-container .form,
+.gradio-container .block { border-radius: 2px !important; }
+.gradio-container .group {
+  border: 0 !important;
+  background: transparent !important;
+  box-shadow: none !important;
+  padding: 0 !important;
+  margin: 0 !important;
+}
+.gradio-container textarea,
+.gradio-container input,
+.gradio-container select { border-radius: 2px !important; font-size: 15px !important; }
+.gradio-container label,
+.gradio-container .label-wrap { font-size: 14.5px !important; font-weight: 500 !important; }
+
+/* Primary actions are compact; utilities are quiet and secondary. */
+.gradio-container button {
+  border-radius: 2px !important;
+  font-size: 14.5px !important;
+  font-weight: 600 !important;
+  box-shadow: none !important;
 }
-.copy-row { margin-top: -4px; }
-.copy-row button { min-height: 34px !important; }
-.gradio-container button { border-radius: 3px !important; font-weight: 600 !important; font-size: 15px !important; }
-.action-btn button, .copy-btn button {
-  background: #5f817b !important;
+.action-btn { width: fit-content !important; max-width: 100% !important; }
+.action-btn button {
+  width: auto !important;
+  min-height: 36px !important;
+  padding: 7px 14px !important;
+  background: var(--fl-accent) !important;
   color: #fff !important;
-  border: 1px solid #5f817b !important;
+  border: 1px solid var(--fl-accent) !important;
 }
-.action-btn button:hover, .copy-btn button:hover { background: #536f6a !important; border-color: #536f6a !important; }
-.gradio-container .form, .gradio-container .block { border-radius: 3px !important; }
-.gradio-container textarea, .gradio-container input { border-radius: 2px !important; }
-.form-note { margin-top: -3px; margin-bottom: 9px; font-size: .92rem; opacity: .72; }
-.wide-table { width: 100% !important; }
-.bottom-spacer { height: 110px; width: 100%; }
-.tabs, .tabitem { padding-bottom: 26px !important; }
-.context-card {
-  border: 1px solid var(--border-color-primary);
-  border-left: 4px solid #708B86;
-  background: var(--background-fill-secondary);
-  padding: 10px 14px;
-  margin: 8px 0 16px;
-  border-radius: 2px;
+.action-btn button:hover {
+  background: var(--fl-accent-hover) !important;
+  border-color: var(--fl-accent-hover) !important;
 }
-.context-card p { margin: 0 !important; }
-.start-card {
-  border: 1px solid var(--border-color-primary);
+.copy-btn { width: fit-content !important; max-width: 100% !important; margin-top: 3px !important; }
+.copy-btn button {
+  width: auto !important;
+  min-height: 31px !important;
+  padding: 5px 10px !important;
+  background: transparent !important;
+  color: var(--body-text-color-subdued) !important;
+  border: 1px solid var(--fl-rule) !important;
+  font-weight: 500 !important;
+}
+.copy-btn button:hover {
+  background: var(--background-fill-secondary) !important;
+  color: var(--body-text-color) !important;
+}
+
+/* Tokens are data, so monospace is appropriate here and nowhere else. */
+.token-wrap { display: flex; flex-wrap: wrap; gap: 5px; padding: 6px 0 10px; line-height: 1.85; }
+.token {
   background: var(--background-fill-secondary);
-  padding: 14px 16px;
-  min-height: 150px;
+  border: 1px solid var(--fl-rule);
   border-radius: 2px;
+  padding: 2px 6px;
+  font-family: var(--fl-mono) !important;
+  font-size: 12px;
 }
-.start-card h3 { margin-top: 0; }
-.graph-note { font-size: .95rem; opacity: .72; margin-top: 2px; }
+.token.selected { border-color: var(--fl-accent); outline: 1px solid var(--fl-accent); font-weight: 600; }
+.token sup { opacity: .58; margin-right: 4px; }
+
+/* Result tables: normal-weight data, tabular numerics, clear heading. */
 .table-heading {
-  margin: 0 0 -34px !important;
+  margin: 2px 0 -32px !important;
   padding: 4px 58px 0 0 !important;
-  min-height: 34px;
+  min-height: 32px;
   position: relative;
   z-index: 3;
   pointer-events: none;
-  font-size: 1.20rem !important;
-  font-weight: 700 !important;
+  font-size: 1.16rem !important;
+  font-weight: 600 !important;
   line-height: 1.22 !important;
 }
-.result-table .label-wrap,
-.result-table .label-wrap span,
-.result-table label,
-.result-table label span,
-.result-table [data-testid="block-label"],
-.result-table [data-testid="block-label"] span,
-.result-table .block-label,
-.result-table .block-title {
-  font-size: 19px !important;
-  font-weight: 700 !important;
-  line-height: 1.30 !important;
+.result-table table,
+.result-table [role="grid"] {
+  font-family: var(--fl-body) !important;
+  font-size: 14.25px !important;
+  font-variant-numeric: tabular-nums;
 }
 .result-table table thead th,
 .result-table table thead th *,
 .result-table [role="columnheader"],
 .result-table [role="columnheader"] * {
-  font-size: 16.75px !important;
-  font-weight: 700 !important;
-  line-height: 1.25 !important;
+  font-size: 14.25px !important;
+  font-weight: 650 !important;
+  line-height: 1.24 !important;
+}
+.result-table table tbody td,
+.result-table [role="gridcell"] {
+  font-size: 14.25px !important;
+  font-weight: 400 !important;
+  line-height: 1.32 !important;
 }
-/* Gradio native fullscreen is intercepted and converted to an in-place focus mode.
-   Nothing is moved to the top of the HF iframe: the original component expands where the user clicked it. */
+.result-table .label-wrap,
+.result-table [data-testid="block-label"],
+.result-table .block-label,
+.result-table .block-title { display: none !important; }
+
+/* Plots use the body face for axes/legends; titles can retain their chart style. */
+.fl-plot svg text { font-family: var(--fl-body) !important; }
+
+/* Existing in-place focus behavior is preserved exactly. */
 .fl-plot.featurelens-inline-focus,
 .result-table.featurelens-inline-focus {
   position: relative !important;
   z-index: 5000 !important;
   background: var(--background-fill-primary) !important;
-  border: 1px solid var(--border-color-primary) !important;
-  box-shadow: 0 12px 36px rgba(0, 0, 0, .42) !important;
-  border-radius: 4px !important;
-}
-.fl-plot.featurelens-inline-focus {
-  transform-origin: top left !important;
-}
-.result-table.featurelens-inline-focus {
-  overflow: visible !important;
+  border: 1px solid var(--fl-rule) !important;
+  box-shadow: 0 10px 28px rgba(0, 0, 0, .34) !important;
+  border-radius: 2px !important;
 }
-.candidate-help { opacity: .78; font-size: .97rem; margin-top: -2px; }
+.fl-plot.featurelens-inline-focus { transform-origin: top left !important; }
+.result-table.featurelens-inline-focus { overflow: visible !important; }
+
+.wide-table { width: 100% !important; }
+.bottom-spacer { height: 86px; width: 100%; }
+.tabs, .tabitem { padding-bottom: 22px !important; }
+
+/* Keep prose readable instead of spanning the full analytical canvas. */
+.prose p,
+.prose li { max-width: 80ch; }
+
 @media (max-width: 900px) {
   .gradio-container { width: 100% !important; padding-left: 12px !important; padding-right: 12px !important; }
+  .action-btn, .copy-btn { width: 100% !important; }
+  .action-btn button, .copy-btn button { width: 100% !important; }
 }
 """
-
 THEME = gr.themes.Base(
     primary_hue="teal",
-    secondary_hue="stone",
-    neutral_hue="stone",
+    secondary_hue="gray",
+    neutral_hue="gray",
     radius_size="sm",
 )
 
@@ -193,10 +305,10 @@ COPY_JS = r"""
   const oldLabel = button ? button.innerText : null;
   const signal = () => {
     if (!button) return;
-    button.innerText = "✓ Copied with headers";
+    button.innerText = "Copied";
     button.disabled = true;
     window.setTimeout(() => {
-      button.innerText = oldLabel || "Copy table with headers";
+      button.innerText = oldLabel || "Copy TSV";
       button.disabled = false;
     }, 1200);
   };
@@ -362,7 +474,7 @@ def _tsv(frame: pd.DataFrame) -> str:
     return frame.to_csv(sep="\t", index=False, lineterminator="\n")
 
 
-def _copy_button(label: str = "Copy table with headers") -> gr.Button:
+def _copy_button(label: str = "Copy TSV") -> gr.Button:
     return gr.Button(label, size="sm", variant="primary", elem_classes=["copy-btn"])
 
 
@@ -371,7 +483,7 @@ def _table_heading(text: str) -> gr.HTML:
 
 
 def _copy_ack(_text: str) -> None:
-    gr.Info("Copied table with headers.", duration=1.2)
+    gr.Info("Copied TSV with headers.", duration=1.0)
 
 
 def _bind_copy(button: gr.Button, source: gr.Textbox) -> None:
@@ -390,64 +502,35 @@ def _analysis_metrics_markdown(result) -> str:
 
 
 def _intervention_metrics_markdown(result) -> str:
-    drift = f"Execution-context null drift — JS: **{result.execution_drift_js:.2e}**"
+    drift = f"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}**"
+        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."
-    )
+    lines = [
+        f"Feature activation **{result.feature_activation:.4f}** · Δ coefficient **{result.delta_activation:+.4f}** · perturbation L2 **{result.perturbation_norm:.4f}**",
+        f"Next-token JS **{result.js_divergence:.6f}** · random mean **{result.random_js_divergence:.6f} ± {result.random_js_std:.6f}** · specificity **{result.js_specificity_ratio:.2f}×** · tail **{result.js_empirical_p:.3f}**",
+        f"Execution context: {drift}",
+    ]
     if result.baseline_sequence_logprob is not None:
         tokens = " ".join(repr(token) for token in result.target_tokens)
-        target = (
-            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-ensemble mean: **{result.random_sequence_logprob:.4f}**  \n"
-            f"SAE Δ sequence log p: **{result.sequence_logprob_delta:+.4f}** · "
-            f"random signed mean Δ: **{result.random_sequence_logprob_delta:+.4f}**  \n"
-            f"SAE Δ mean log p/token: **{result.mean_logprob_delta:+.4f}** · "
-            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 = ""
+        lines.extend([
+            f"Target {tokens} · baseline log p **{result.baseline_sequence_logprob:.4f}** · SAE edit **{result.modified_sequence_logprob:.4f}**",
+            f"Δ mean log p/token **{result.mean_logprob_delta:+.4f}** · random mean |Δ| **{result.random_abs_mean_logprob_delta:.4f} ± {result.random_mean_logprob_std:.4f}** · specificity **{result.target_specificity_ratio:.2f}×** · tail **{result.target_empirical_p:.3f}**",
+        ])
     if abs(result.feature_activation) < 1e-12:
-        inactive = (
-            "  \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 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._"
-    )
-
+        lines.append("_This feature is inactive at the selected token; ablate/scale therefore has zero native coefficient to remove._")
+    elif result.baseline_text == result.modified_text:
+        lines.append("_Greedy text is unchanged; the probability-level metrics above are more sensitive than deterministic decoding._")
+    return "  \n".join(lines)
 
 def _dose_metrics_markdown(result) -> str:
     tokens = " ".join(repr(token) for token in result.target_tokens)
-    inactive = ""
-    if abs(result.feature_activation) < 1e-12:
-        inactive = " **The feature is inactive here, so multiplicative scaling is flat by construction.**"
+    inactive = " · inactive at this token" if abs(result.feature_activation) < 1e-12 else ""
     return (
-        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 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}**."
+        f"Feature activation **{result.feature_activation:.4f}**{inactive} · target {tokens}  \n"
+        f"Reference: **1× no edit** · execution drift mean log p/token **{result.execution_drift_mean_logprob:+.2e}** · JS **{result.execution_drift_js:.2e}**"
     )
 
-
 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)
@@ -477,58 +560,35 @@ def _feature_set_metrics_markdown(result) -> str:
 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."
+        f"Target {tokens} · additive expectation **{result.additive_expected_mean_delta:+.4f}** · "
+        f"joint effect **{result.joint_mean_delta:+.4f}** · interaction excess **{result.interaction_excess_mean_delta:+.4f}** "
+        f"(normalized **{result.normalized_interaction:+.3f}**)  \n"
+        f"Execution drift **{result.execution_drift_mean_logprob:+.2e}** mean log p/token. "
+        "_Non-additivity is downstream interaction evidence, not a circuit claim._"
     )
 
-
 def _paraphrase_metrics_markdown(result) -> str:
     return (
-        "#### Robustness metrics\n"
-        "**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."
+        "**Selected token** · "
+        f"Jaccard **{result.topk_jaccard:.3f}** · sparse cosine **{result.sparse_cosine:.3f}** · "
+        f"shared displayed features **{result.shared_top_n}/{result.top_n}**  \n"
+        "**Prompt-wide max pool** · "
+        f"Jaccard **{result.promptwide_jaccard:.3f}** · cosine **{result.promptwide_cosine:.3f}**"
     )
 
-
 def _concept_metrics_markdown(result) -> str:
     coverage = f"{result.active_prompt_count}/{result.total_prompt_count}"
     if result.leading_concept is None:
-        leader = (
-            "The feature was **inactive in every sampled prompt**. No concept leader is reported; "
-            "increase the sample or inspect a different feature."
-        )
+        leader = "inactive in every sampled prompt"
     elif result.leading_ratio is None:
-        leader = (
-            f"Highest prompt-wide mean activation: **{result.leading_concept}**; the runner-up mean was zero."
-        )
+        leader = f"highest mean: **{result.leading_concept}** (runner-up mean 0)"
     else:
-        leader = (
-            f"Highest prompt-wide mean activation: **{result.leading_concept}** "
-            f"(**{result.leading_ratio:.2f}×** the runner-up mean)."
-        )
+        leader = f"highest mean: **{result.leading_concept}** (**{result.leading_ratio:.2f}×** runner-up)"
     return (
-        f"Feature **{result.feature_id}**, layer **{result.layer}** · "
-        f"{result.prompts_per_concept} controlled prompts/concept · active in **{coverage}** sampled prompts.  \n"
-        f"{leader}  \n\n"
-        "Each prompt is summarized by the feature's **maximum activation across its non-padding tokens**. "
-        "This is an exploratory contrast scan, not an automatic semantic label; held-out AUROC/F1 remains the stronger evidence."
+        f"Feature **{result.feature_id}** · layer **{result.layer}** · active in **{coverage}** prompts · {leader}.  \n"
+        "_Exploratory prompt-wide contrast; use the Study tab for held-out evidence._"
     )
 
-
 def _trace_metrics_markdown(result) -> str:
     if result.max_token_index is None:
         peak = "Feature is inactive at every prompt token."
@@ -545,111 +605,70 @@ def _trace_metrics_markdown(result) -> str:
 
 def _geometry_metrics_markdown(result) -> str:
     if result.alignment_ratio > 1.05:
-        geometry = "The activation-weighted ablation directions are net **aligned**."
+        geometry = "net aligned"
     elif result.alignment_ratio < 0.95:
-        geometry = "The activation-weighted ablation directions show net **cancellation**."
+        geometry = "net cancelling"
     else:
-        geometry = "The joint norm is close to the orthogonal/independent reference."
+        geometry = "near the independent-direction reference"
     return (
-        f"Selected features: **{', '.join(str(x) for x in result.feature_ids)}** · layer **{result.layer}**  \n"
-        f"Mean |decoder cosine|: **{result.mean_abs_decoder_cosine:.3f}** · "
-        f"max |decoder cosine|: **{result.max_abs_decoder_cosine:.3f}**  \n"
-        f"Joint ablation L2: **{result.joint_ablation_norm:.4f}** · independent-direction reference: "
-        f"**{result.independent_norm:.4f}** · geometry ratio: **{result.alignment_ratio:.3f}×**  \n"
-        f"{geometry} This diagnoses SAE decoder geometry; it does not by itself establish downstream causal interaction."
+        f"Features **{', '.join(str(x) for x in result.feature_ids)}** · layer **{result.layer}** · "
+        f"mean |cos| **{result.mean_abs_decoder_cosine:.3f}** · max |cos| **{result.max_abs_decoder_cosine:.3f}**  \n"
+        f"Joint L2 **{result.joint_ablation_norm:.4f}** · independent reference **{result.independent_norm:.4f}** · "
+        f"ratio **{result.alignment_ratio:.3f}×** ({geometry})."
     )
 
-
 def _contrastive_metrics_markdown(result) -> str:
-    direction = "toward A" if result.delta_log_odds > 0 else ("toward B" if result.delta_log_odds < 0 else "neither way")
+    direction = "toward A" if result.delta_log_odds > 0 else ("toward B" if result.delta_log_odds < 0 else "no shift")
     return (
-        f"Feature **{result.feature_id}** · activation **{result.feature_activation:.4f}** · perturbation L2 "
-        f"**{result.perturbation_norm:.4f}**  \n"
-        f"Exact-sequence log-odds A−B — baseline: **{result.baseline_log_odds:+.4f}** · "
-        f"SAE edit: **{result.modified_log_odds:+.4f}** · causal shift: **{result.delta_log_odds:+.4f}** ({direction}).  \n"
-        f"Token-normalized preference shift: **{result.delta_normalized_preference:+.4f}**.  \n"
-        f"Random ensemble ({result.random_control_count}) |Δ log-odds| mean: **{result.random_abs_mean_delta:.4f}** "
-        f"± **{result.random_delta_std:.4f}** · SAE/random ratio: **{result.specificity_ratio:.2f}×** · "
-        f"empirical tail p: **{result.empirical_p:.3f}**.  \n\n"
-        "This asks whether the intervention changes the model's **relative preference between two specified continuations**, "
-        "which is stricter than showing that one continuation's probability moved in isolation."
+        f"Feature **{result.feature_id}** · activation **{result.feature_activation:.4f}** · perturbation L2 **{result.perturbation_norm:.4f}**  \n"
+        f"Exact-sequence log-odds A−B: baseline **{result.baseline_log_odds:+.4f}** · edit **{result.modified_log_odds:+.4f}** · "
+        f"shift **{result.delta_log_odds:+.4f}** ({direction})  \n"
+        f"Token-normalized shift **{result.delta_normalized_preference:+.4f}** · random mean |Δ| **{result.random_abs_mean_delta:.4f} ± {result.random_delta_std:.4f}** · "
+        f"specificity **{result.specificity_ratio:.2f}×** · tail **{result.empirical_p:.3f}**"
     )
 
-
-
-
 def _discovery_metrics_markdown(result) -> str:
     if not result.candidate_ids:
-        if result.ranking_mode == "causal_ready":
-            return (
-                f"No positively selective **current-token-active** candidates were found for **{result.concept}** "
-                f"at layer **{result.layer}** in this live batch. Try another token/layer or use Balanced selectivity "
-                "to discover concept-associated features elsewhere in the prompt."
-            )
-        return (
-            f"No positively selective candidate features were found for **{result.concept}** at layer "
-            f"**{result.layer}** in this small live batch. Increase the sample or try another layer."
-        )
+        scope = "current-token-active " if result.ranking_mode == "causal_ready" else ""
+        return f"No positively selective {scope}candidates found for **{result.concept}** at layer **{result.layer}** in this live batch."
+
     ranking = {
-        "balanced_selectivity": "balanced selectivity × coverage × log-magnitude",
-        "raw_mean_difference": "raw target-minus-other mean activation",
-        "causal_ready": "causal-ready evidence at the current Workbench token",
+        "balanced_selectivity": "balanced selectivity",
+        "raw_mean_difference": "raw mean difference",
+        "causal_ready": "causal-ready evidence",
     }[result.ranking_mode]
-    context = (
-        f"Current Workbench token **{result.current_token_index}** was checked in the same model batch. "
-        "The default candidate prefers the highest-ranked feature active at that token when one exists."
-        if result.current_context_available
-        else "No Workbench prompt was available, so current-prompt compatibility was not evaluated."
-    )
-    stability = ""
-    if result.split_half_jaccard is not None and result.split_half_k is not None:
-        stability = (
-            f"  \nSplit-half shortlist stability from the same activation batch: "
-            f"**{result.split_half_shared_count}** shared candidate(s), Jaccard **{result.split_half_jaccard:.3f}**. "
-            f"This is a small-sample sensitivity diagnostic, not a reliability estimate."
+    lines = [
+        f"**{result.concept}** · layer **{result.layer}** · {result.prompts_per_concept} prompts/concept · **{len(result.candidate_ids)}** candidates by {ranking}",
+    ]
+    if result.current_context_available:
+        lines.append(
+            f"Current token **{result.current_token_index}** · active candidates **{result.displayed_current_active_count}/{len(result.candidate_ids)}**"
+        )
+    if result.split_half_jaccard is not None:
+        lines.append(
+            f"Split-half shortlist · shared **{result.split_half_shared_count}** · Jaccard **{result.split_half_jaccard:.3f}**"
         )
     if result.resample_replicates and result.resample_mean_support is not None:
-        stability += (
-            f"  \nDeterministic balanced-resample support ({result.resample_replicates} resamples, same activations): "
-            f"mean support across displayed candidates **{result.resample_mean_support:.1%}**; "
-            f"**{result.resample_high_support_count}/{len(result.candidate_ids)}** displayed candidates appeared in at least 75% "
-            "of resampled shortlists. This is still a live small-sample stability diagnostic, not a confidence interval."
+        lines.append(
+            f"{result.resample_replicates} resamples · mean shortlist support **{result.resample_mean_support:.1%}** · "
+            f"≥75% support **{result.resample_high_support_count}/{len(result.candidate_ids)}** · not a confidence interval"
         )
-    return (
-        f"Concept **{result.concept}** · layer **{result.layer}** · "
-        f"{result.prompts_per_concept} prompts/concept.  \n"
-        f"Showing **{len(result.candidate_ids)}** candidates ranked by **{ranking}**.  \n"
-        f"Displayed candidates active at the selected Workbench token: "
-        f"**{result.displayed_current_active_count}/{len(result.candidate_ids)}**.  \n"
-        f"{context}{stability}  \n\n"
-        "This is **candidate discovery**, not a semantic label. The offline held-out AUROC/F1 pipeline remains "
-        "the standard for a concept-selectivity claim."
-    )
-
+    lines.append("_Live discovery is exploratory; semantic claims belong to the held-out Study results._")
+    return "  \n".join(lines)
 
 def _candidate_screen_metrics_markdown(result) -> str:
     tokens = " ".join(repr(token) for token in result.target_tokens)
     if result.rows:
         top = result.rows[0]
-        strongest = (
-            f"Strongest screened target effect: feature **{int(top[1])}** with "
-            f"Δ mean log p/token **{float(top[5]):+.4f}** and next-token JS **{float(top[7]):.6f}**."
-        )
+        strongest = f"top feature **{int(top[1])}** · Δ mean log p/token **{float(top[5]):+.4f}** · JS **{float(top[7]):.6f}**"
     else:
-        strongest = "No candidate rows were produced."
+        strongest = "no candidate rows"
     return (
-        f"Screened **{result.candidate_count}** candidate feature(s); **{result.active_feature_count}** were active "
-        f"at the selected Workbench token. Target continuation: {len(result.target_tokens)} token(s): {tokens}.  \n"
-        f"{strongest}  \n"
-        f"Execution-context null drift: mean log p/token **{result.execution_drift_mean_logprob:+.2e}**, "
-        f"JS **{result.execution_drift_js:.2e}**.  \n\n"
-        "This is a **triage screen**: all ablations share one batched zero-edit reference, but no random-control "
-        "ensemble is spent here. Take a promising feature into **Workbench → II. Single-feature causal test** for "
-        "the full 8-direction specificity comparison."
+        f"Screened **{result.candidate_count}** candidates · active **{result.active_feature_count}** · target {tokens} · {strongest}  \n"
+        f"Null drift mean log p/token **{result.execution_drift_mean_logprob:+.2e}** · JS **{result.execution_drift_js:.2e}**. "
+        "_This is a triage screen; no random-control ensemble is spent here._"
     )
 
-
-
 def _spearman_rank_corr(left: list[float], right: list[float]) -> float | None:
     """Descriptive Spearman correlation with tie-aware average ranks."""
     if len(left) != len(right) or len(left) < 2:
@@ -755,9 +774,7 @@ def _candidate_alignment_outputs(
         f"**{int(top_target['Feature id'])}** · strongest next-token distribution shift: **{int(top_js['Feature id'])}**.  \n"
         f"Spearman ρ(candidate score, |target effect|): **{fmt_rho(rho_target)}** · "
         f"ρ(candidate score, next-token JS): **{fmt_rho(rho_js)}**.  \n\n"
-        "This is the project's central association-vs-causality diagnostic: a feature can rank highly by concept evidence yet "
-        "rank weakly by downstream target effect, or vice versa. With only a handful of screened features and no random-control "
-        "ensemble in triage, these correlations are **descriptive**, not significance claims."
+        "_descriptive shortlist comparison; triage does not use random controls._"
     )
 
     chart = table[["Feature id", "Candidate score", "|Δ mean log p/token|", "Discovery rank", "Target-effect rank", "Next-token JS"]].copy()
@@ -824,27 +841,16 @@ def _controlled_candidate_shortlist(
 
 def _candidate_specificity_metrics_markdown(result) -> str:
     tokens = " ".join(repr(token) for token in result.target_tokens)
+    strongest = "no controlled rows"
     if result.rows:
         top = result.rows[0]
-        strongest = (
-            f"Highest target-specificity ratio: feature **{int(top[1])}** at **{float(top[9]):.2f}×** "
-            f"the random mean |effect| (empirical tail **{float(top[10]):.3f}**)."
-        )
-    else:
-        strongest = "No controlled candidate rows were produced."
+        strongest = f"top target specificity **{int(top[1])}** at **{float(top[9]):.2f}×** random mean |effect| · tail **{float(top[10]):.3f}**"
     return (
-        f"Compared **{result.candidate_count}** candidate feature(s); **{result.active_feature_count}** were active "
-        f"at the selected Workbench token. Each candidate uses **{result.random_control_count}** norm-matched random controls.  \n"
-        f"Target continuation: {len(result.target_tokens)} token(s): {tokens}.  \n"
-        f"{strongest}  \n"
-        f"Execution-context null drift: mean log p/token **{result.execution_drift_mean_logprob:+.2e}**, "
-        f"JS **{result.execution_drift_js:.2e}**.  \n\n"
-        "This is the controlled follow-up to triage: target-specificity compares |Δ mean log p/token| against the "
-        "candidate's own norm-matched random ensemble; JS-specificity does the same for the local next-token distribution. "
-        "With eight controls, empirical tail values remain intentionally coarse."
+        f"Compared **{result.candidate_count}** candidates · active **{result.active_feature_count}** · "
+        f"**{result.random_control_count}** random controls each · target {tokens} · {strongest}  \n"
+        f"Null drift mean log p/token **{result.execution_drift_mean_logprob:+.2e}** · JS **{result.execution_drift_js:.2e}**"
     )
 
-
 def _controlled_evidence_patterns(
     specificity_table: pd.DataFrame | None,
 ) -> tuple[str, pd.DataFrame]:
@@ -901,8 +907,7 @@ def _controlled_evidence_patterns(
     )
     summary = (
         f"Controlled evidence patterns — {descriptions}.  \n\n"
-        "These labels summarize **effect ratios**, not statistical significance. With eight random controls, empirical tail "
-        "values are coarse; the offline benchmark is the place for stronger uncertainty estimates."
+        "_Pattern labels summarize effect ratios, not statistical significance._"
     )
     return summary, out
 
@@ -937,33 +942,27 @@ def _cross_target_shortlist(specificity_table: pd.DataFrame | None, limit: int =
 def _cross_target_metrics_markdown(result) -> str:
     feature_text = ", ".join(str(feature_id) for feature_id in result.feature_ids)
     target_text = ", ".join(repr(target) for target in result.targets)
+    series_text = " · ".join(
+        f"Feature {chr(65 + idx)} = **{feature_id}**" for idx, feature_id in enumerate(result.feature_ids)
+    )
+    lines = [
+        f"Features **{feature_text}** · targets {target_text} · active **{result.active_feature_count}/{len(result.feature_ids)}**",
+        series_text,
+    ]
     if result.summary_rows:
         strongest = result.summary_rows[0]
-        lead = (
-            f"Largest screened cross-target effect: feature **{int(strongest[0])}** on **{strongest[1]!r}** "
-            f"with Δ mean log p/token **{float(strongest[2]):+.4f}**."
+        lines.append(
+            f"Largest effect: **{int(strongest[0])}** on **{strongest[1]!r}** · Δ mean log p/token **{float(strongest[2]):+.4f}**"
         )
         patterns = "; ".join(f"{int(row[0])}: {row[10]}" for row in result.summary_rows)
-        profile_text = f"  \nHeuristic target-profile patterns — {patterns}."
-    else:
-        lead = "No cross-target rows were produced."
-        profile_text = ""
-    pairwise_text = ""
+        lines.append(f"Profiles · {patterns}")
     if result.pairwise_rows:
         top_pair = result.pairwise_rows[0]
-        pairwise_text = (
-            f"  \nLargest token-normalized pairwise preference shift: feature **{int(top_pair[0])}**, "
-            f"**{top_pair[1]!r} vs {top_pair[2]!r}**, Δ(A−B) **{float(top_pair[3]):+.4f}**."
+        lines.append(
+            f"Largest pairwise preference shift: **{int(top_pair[0])}** · {top_pair[1]!r} vs {top_pair[2]!r} · **{float(top_pair[3]):+.4f}**"
         )
-    return (
-        f"Profiled feature(s) **{feature_text}** across exact continuation(s) {target_text}; "
-        f"**{result.active_feature_count}/{len(result.feature_ids)}** selected features were active at the Workbench token.  \n"
-        f"{lead}{profile_text}{pairwise_text}  \n\n"
-        "This is a **target-profile screen** using native SAE ablations and a batched no-edit reference for each continuation. "
-        "The profile labels are descriptive heuristics, and pairwise shifts compare token-normalized target effects; neither spends "
-        "random controls. Use Controlled candidate specificity for matched-random causal claims."
-    )
-
+    lines.append("_Target-profile screen; matched-random specificity is reported above._")
+    return "  \n".join(lines)
 
 def _controlled_alignment_outputs(
     discovery_table: pd.DataFrame | None,
@@ -991,9 +990,7 @@ def _controlled_alignment_outputs(
         return "", pd.DataFrame(columns=columns), pd.DataFrame()
     if discovery_table is None:
         return (
-            "Controlled specificity results are available, but the concept-discovery table is not present in this browser "
-            "session, so discovery-rank alignment cannot be reconstructed. The controlled evidence-pattern summary above "
-            "remains valid; rerun discovery only if you specifically want association-rank alignment.",
+            "Controlled results are available, but discovery evidence is not present in this browser session, so rank alignment cannot be reconstructed.",
             pd.DataFrame(columns=columns),
             pd.DataFrame(),
         )
@@ -1003,8 +1000,7 @@ def _controlled_alignment_outputs(
         return "", pd.DataFrame(columns=columns), pd.DataFrame()
     if discovery.empty or "Feature id" not in discovery:
         return (
-            "Controlled specificity results are available, but no concept-discovery evidence is currently populated. "
-            "The controlled evidence-pattern summary above remains valid without that association table.",
+            "Controlled results are available, but discovery evidence is not currently populated.",
             pd.DataFrame(columns=columns),
             pd.DataFrame(),
         )
@@ -1114,51 +1110,31 @@ def _controlled_alignment_outputs(
 
 
 def _cue_context_metrics_markdown(result) -> str:
-    active = ", ".join(
-        f"{cue}: {count}/{len(result.stems)} contexts"
-        for cue, count in result.cue_active_context_counts.items()
-    )
-    interpretation = (
-        "No tested cue activated the feature."
-        if result.dominant_cue is None or result.active_condition_count == 0
-        else (
-            f"**Cue-dominant pattern:** `{result.dominant_cue}` activates in every tested context while all "
-            "other tested cues are inactive. Under this matrix, the evidence is much more consistent with a "
-            "lexical/cue-specific response than with a mathematics-specific response."
-            if result.dominant_cue_context_count == len(result.stems)
-            and result.off_dominant_active_count == 0
-            else (
-                f"The strongest cue is `{result.dominant_cue}` ({result.dominant_cue_context_count}/{len(result.stems)} "
-                "contexts), but other cues or context dependence remain. Treat the pattern as mixed/context-sensitive."
-            )
-        )
+    active = " · ".join(
+        f"{cue} {count}/{len(result.stems)}" for cue, count in result.cue_active_context_counts.items()
     )
+    if result.dominant_cue is None or result.active_condition_count == 0:
+        interpretation = "No tested cue activated the feature."
+    elif result.dominant_cue_context_count == len(result.stems) and result.off_dominant_active_count == 0:
+        interpretation = f"**Cue-dominant pattern:** `{result.dominant_cue}` activates in every tested context; this is more consistent with a lexical/cue-specific response in this matrix."
+    else:
+        interpretation = f"Strongest cue: `{result.dominant_cue}` ({result.dominant_cue_context_count}/{len(result.stems)} contexts); pattern remains context-dependent."
     return (
-        f"Feature **{result.feature_id}**, layer **{result.layer}** · active in "
-        f"**{result.active_condition_count}/{result.condition_count}** stem × cue conditions.  \n"
-        f"Cue coverage — {active}.  \n\n"
-        f"{interpretation}  \n\n"
-        "This is a controlled diagnostic over the tested stems/cues, not a universal semantic label."
+        f"Feature **{result.feature_id}** · layer **{result.layer}** · active **{result.active_condition_count}/{result.condition_count}** conditions  \n"
+        f"Cue coverage · {active}  \n{interpretation}"
     )
 
-
 def _cue_metrics_markdown(result) -> str:
     return (
-        f"Feature **{result.feature_id}**, layer **{result.layer}** · active for "
-        f"**{result.active_cue_count}/{result.cue_count}** tested completion cues at the final token.  \n"
-        "This helps distinguish a concept-associated feature from a lexical/structural completion-cue feature. "
-        "It is a controlled diagnostic, not a feature label."
+        f"Feature **{result.feature_id}** · layer **{result.layer}** · active for "
+        f"**{result.active_cue_count}/{result.cue_count}** tested cues at the final token."
     )
 
-
 def _global_context_markdown(prompt: str, layer: int, result) -> str:
     token = result.tokens[result.token_index] if result.tokens else ""
     short = prompt[:120] + ("…" if len(prompt) > 120 else "")
     return (
-        "**Current Workbench context** — "
-        f"Prompt: `{short}` · layer **{int(layer)}** · token **{result.token_index}** ({token!r}).  \n"
-        "Panels marked **Uses current Workbench context** inherit this prompt/layer/token. "
-        "Feature selectors remain editable inside each experiment."
+        f"**Context** · layer **{int(layer)}** · token **{result.token_index}** ({token!r}) · `{short}`"
     )
 
 @gpu(duration=30)
@@ -1836,8 +1812,10 @@ def run_candidate_cross_target_profile(
         table = pd.DataFrame(result.rows, columns=columns)
         chart = pd.DataFrame(
             result.chart_rows,
-            columns=["Target continuation", "Feature", "Δ mean log p/token"],
+            columns=["Target continuation", "Feature id", "Δ mean log p/token"],
         )
+        series_lookup = {feature_id: f"Feature {chr(65 + idx)}" for idx, feature_id in enumerate(result.feature_ids)}
+        chart["Series"] = chart["Feature id"].map(lambda value: series_lookup.get(int(value), "Feature"))
         summary_columns = [
             "Feature id",
             "Strongest target",
@@ -1865,7 +1843,9 @@ def run_candidate_cross_target_profile(
         pairwise_chart = pairwise_table.copy()
         if not pairwise_chart.empty:
             pairwise_chart["Target pair"] = pairwise_chart["Target A"].astype(str) + " vs " + pairwise_chart["Target B"].astype(str)
-            pairwise_chart["Feature"] = pairwise_chart["Feature id"].astype(str)
+            pairwise_chart["Series"] = pairwise_chart["Feature id"].map(
+                lambda value: series_lookup.get(int(value), "Feature")
+            )
         return (
             _cross_target_metrics_markdown(result),
             table,
@@ -1938,10 +1918,7 @@ def use_candidate_feature(candidate_id: str):
     if candidate_id is None or str(candidate_id).strip() == "":
         raise gr.Error("Run concept-guided discovery and choose a candidate first.")
     value = str(int(float(candidate_id)))
-    status = (
-        f"**Feature {value} loaded.** It is now selected in Single-feature causal test, "
-        "Scale dose-response, Contrastive preference, and Feature evidence. You can still change any selector independently."
-    )
+    status = f"Feature {value} loaded for the feature-level experiments."
     return value, value, value, value, status
 
 
@@ -1962,53 +1939,33 @@ def set_mode_help(mode: str):
 with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_width=True) as demo:
     gr.HTML(
         '<header class="hero">'
-        '<h1>FeatureLens <span style="font-size:.48em;opacity:.58;font-weight:400">v0.13</span></h1>'
-        '<div class="subtitle">Causal Interpretability Workbench</div>'
-        '<div class="question">Discover sparse features, test robustness, and separate correlation from causal influence.</div>'
+        '<h1>FeatureLens</h1>'
+        '<div class="subtitle">Sparse-feature analysis for Qwen3-1.7B and Qwen-Scope SAEs.</div>'
         '</header>'
     )
 
     global_context = gr.Markdown(
-        "**Current Workbench context:** none yet. Go to **Workbench → I. Inspect a prompt location**, "
-        "set the prompt/layer/token, then click **Inspect sparse features**.",
+        "**Context:** no prompt location selected yet.",
         elem_classes=["context-card"],
     )
 
-    with gr.Tab("Start here"):
+    with gr.Tab("Guide"):
         gr.Markdown(
-            "## Start here\n"
-            "FeatureLens is organized as a short evidence workflow. You do **not** need to know a feature id before "
-            "starting: inspect a prompt first, or use **Feature evidence → Concept-guided candidate discovery**."
+            "## Working with the app\n"
+            "Start in **Workbench** to choose a prompt, layer, and token. Use **Feature evidence** when you "
+            "want to find candidates rather than start from a feature id. Return to Workbench or **Feature sets** "
+            "for interventions, and use **Paraphrases**, **Layers**, and **Study** for robustness and aggregate evidence.",
+            elem_classes=["guide-intro"],
         )
-        with gr.Row(equal_height=True):
-            gr.HTML(
-                '<div class="start-card"><h3>1. Choose a location</h3>'
-                '<p>In <b>Workbench</b>, enter a prompt, choose a residual layer and token, then click '
-                '<b>Inspect sparse features</b>. This establishes the shared Workbench context.</p></div>'
-            )
-            gr.HTML(
-                '<div class="start-card"><h3>2. Choose evidence</h3>'
-                '<p>Pick a feature in the experiment you want to run. Feature selectors are populated from the latest '
-                'inspection but remain editable. Feature sets use 2–5 features.</p></div>'
-            )
-            gr.HTML(
-                '<div class="start-card"><h3>3. Ask a causal question</h3>'
-                '<p>Ablate/scale features, compare against norm-matched random controls, test dose response, '
-                'preference shifts, robustness, geometry, or concept association.</p></div>'
-            )
         gr.Markdown(
-            "### Plain-language glossary\n"
-            "- **Token:** a chunk of text the model processes.\n"
-            "- **Residual layer:** a checkpoint in the model's internal computation.\n"
-            "- **SAE feature:** one sparse direction used by the autoencoder to represent a residual activation.\n"
-            "- **Ablate:** remove that feature's current contribution. **Scale:** multiply it.\n"
-            "- **Random control:** an equally large residual edit in an unrelated direction.\n"
-            "- **Teacher-forced score:** probability assigned to exact continuation text, even if greedy generation does not change.\n\n"
-            "**Tables:** use the top-right focus control or copy-with-headers action. **Plots:** use the top-right focus control for a bounded reading view; PNG exports use descriptive FeatureLens filenames."
+            "### Evidence, not labels\n"
+            "A high activation only says that a feature is present. Association is evaluated separately from causal effect; "
+            "random-normalized interventions are the stronger live causal check. Stability metrics show how sensitive a result is to wording or sample choice.\n\n"
+            "Dense tables and plots can be focused in place. **Copy TSV** includes the header row."
         )
 
     with gr.Tab("Workbench"):
-        gr.HTML('<div class="section-rule">I. Inspect a prompt location</div>')
+        gr.HTML('<div class="section-rule">Inspect</div>')
         with gr.Row(equal_height=False):
             with gr.Column(scale=5):
                 prompt = gr.Textbox(
@@ -2025,7 +1982,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                         ["I am not fully certain, but the answer may be"],
                     ],
                     inputs=[prompt],
-                    label="Controlled examples",
+                    label="Examples",
                 )
             with gr.Column(scale=3):
                 layer = gr.Dropdown(
@@ -2042,7 +1999,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 top_n = gr.Slider(5, 20, value=12, step=1, label="Displayed active features")
                 analyze_btn = gr.Button("Inspect sparse features", variant="primary", elem_classes=["action-btn"])
 
-        gr.Markdown("#### Prompt tokens\nThe selected prompt token is outlined more strongly.")
+        gr.Markdown("#### Prompt tokens")
         token_view = gr.HTML(
             '<div class="small-note">Prompt tokens appear here after clicking <b>Inspect sparse features</b>.</div>'
         )
@@ -2075,18 +2032,18 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=330,
                 )
 
-        gr.HTML('<div class="section-rule">II. Single-feature causal test</div>')
+        gr.HTML('<div class="section-rule">Single-feature intervention</div>')
         gr.Markdown(
-            "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."
+            "Each edit is compared with eight norm-matched random directions. Add a continuation to score the full exact sequence.",
+            elem_classes=["section-note"],
         )
         with gr.Row(equal_height=False):
             with gr.Column(scale=2):
                 feature_id = gr.Dropdown(
                     choices=[],
                     allow_custom_value=True,
-                    label="Single feature id",
-                    info="Populated from the latest inspection. You can choose another active feature or enter any valid id.",
+                    label="Feature id",
+                    info="Choose an active feature or enter any valid id.",
                 )
                 mode = gr.Dropdown(
                     choices=["ablate", "scale", "inject"],
@@ -2099,9 +2056,9 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     label="Coefficient (unused for ablation)",
                 )
                 target_text = gr.Textbox(
-                    label="Target continuation (optional)",
+                    label="Target continuation",
                     placeholder="e.g. 2x",
-                    info="Exact text appended to the prompt for teacher-forced scoring.",
+                    info="Leave blank to compare next-token distributions only.",
                 )
                 max_new = gr.Slider(
                     4,
@@ -2110,7 +2067,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     step=1,
                     label="Greedy generation length",
                 )
-                intervene_btn = gr.Button("Run single-feature causal test", variant="primary", elem_classes=["action-btn"])
+                intervene_btn = gr.Button("Run intervention", variant="primary", elem_classes=["action-btn"])
                 intervention_metrics = gr.Markdown()
             with gr.Column(scale=3):
                 with gr.Row():
@@ -2137,28 +2094,27 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 target_token_tsv = gr.Textbox(visible="hidden")
                 target_token_copy = _copy_button()
 
-        gr.HTML('<div class="section-rule">III. Single-feature scale dose-response</div>')
+        gr.HTML('<div class="section-rule">Dose response</div>')
         with gr.Group():
-            gr.Markdown("**Uses current Workbench prompt / layer / token.** Choose the feature for this experiment below.")
             with gr.Row(equal_height=True):
                 dose_feature_id = gr.Dropdown(
                     choices=[],
                     allow_custom_value=True,
                     label="Dose-response feature id",
-                    info="Populated from Workbench inspection, or enter any valid feature id directly.",
+                    info="Choose an active feature or enter any valid id.",
                     scale=2,
                 )
                 dose_target_text = gr.Textbox(
                     label="Dose-response target continuation",
                     value="2x",
-                    info="Exact continuation scored across all dose-response conditions.",
+                    info="Exact continuation scored at every multiplier.",
                     scale=2,
                 )
             gr.Markdown(
-                "0× = ablation, 1× = numerical no-edit reference, and 2× = double the native coefficient. "
-                "The six scale conditions are evaluated together against the 1× row."
+                "0× ablates the feature; 1× is the no-edit reference; 2× doubles the native coefficient.",
+                elem_classes=["section-note"],
             )
-            dose_btn = gr.Button("Run scale dose-response", variant="primary", elem_classes=["action-btn"])
+            dose_btn = gr.Button("Measure dose response", variant="primary", elem_classes=["action-btn"])
             dose_metrics = gr.Markdown()
             with gr.Row(equal_height=False):
                 with gr.Column(scale=3):
@@ -2185,19 +2141,17 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                         height=330,
                     )
 
-        gr.HTML('<div class="section-rule">IV. Contrastive continuation preference</div>')
+        gr.HTML('<div class="section-rule">Contrastive preference</div>')
         with gr.Group():
-            gr.Markdown("**Uses current Workbench prompt / layer / token.** Select the feature explicitly below.")
             contrastive_feature_id = gr.Dropdown(
                 choices=[],
                 allow_custom_value=True,
-                label="Contrastive feature id",
-                info="Populated from the latest Workbench inspection; editable here.",
+                label="Feature id",
+                info="Choose an active feature or enter any valid id.",
             )
             gr.Markdown(
-                "Absolute target probability can move because an intervention broadly perturbs the distribution. "
-                "This test asks the stricter question: **does the edit shift preference between two exact continuations?** "
-                "Both continuations are teacher-forced and compared with the same 8-direction norm-matched random ensemble."
+                "Tests whether the edit changes relative preference between two exact continuations, with the same eight-control random baseline.",
+                elem_classes=["section-note"],
             )
             with gr.Row(equal_height=True):
                 contrastive_a = gr.Textbox(label="Continuation A (preferred)", value="2x", scale=2)
@@ -2216,7 +2170,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     scale=1,
                 )
             contrastive_btn = gr.Button(
-                "Run contrastive preference test", variant="primary", elem_classes=["action-btn"]
+                "Compare continuation preference", variant="primary", elem_classes=["action-btn"]
             )
             contrastive_metrics = gr.Markdown()
             with gr.Row(equal_height=False):
@@ -2246,11 +2200,11 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
 
     with gr.Tab("Feature sets"):
         gr.Markdown(
-            "### Distributed sparse representations\n"
-            "Run **Inspect sparse features** in the Workbench first. **Uses current Workbench context:** prompt, layer, "
-            "and token are inherited from that inspection. The feature set below is always editable."
+            "## Feature sets\n"
+            "Jointly edit active SAE features at the current Workbench location.",
+            elem_classes=["guide-intro"],
         )
-        feature_set_location = gr.Markdown("No Workbench inspection has been run yet.")
+        feature_set_location = gr.Markdown("", visible=False)
         feature_set_ids = gr.Dropdown(
             choices=[],
             value=[],
@@ -2260,11 +2214,9 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
             label="Feature set",
         )
 
-        gr.Markdown("#### Joint feature-set causal test")
+        gr.HTML('<div class="section-rule">Joint intervention</div>')
         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>'
+            '<div class="instrument-note">Ablation removes each selected feature at its native coefficient. Scale applies one shared multiplier before the decoder deltas are summed.</div>'
         )
         with gr.Row(equal_height=True):
             set_mode = gr.Dropdown(
@@ -2285,7 +2237,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 lines=1,
                 scale=2,
             )
-        set_btn = gr.Button("Run joint feature-set causal test", variant="primary", elem_classes=["action-btn"])
+        set_btn = gr.Button("Run joint intervention", variant="primary", elem_classes=["action-btn"])
         set_metrics = gr.Markdown()
         with gr.Row(equal_height=False):
             with gr.Column(scale=2):
@@ -2313,8 +2265,8 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
 
         gr.HTML('<div class="section-rule">Set-size sensitivity</div>')
         gr.Markdown(
-            "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."
+            "Ablate the 1, 3, and 5 strongest active features with matched random controls.",
+            elem_classes=["section-note"],
         )
         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", variant="primary", elem_classes=["action-btn"])
@@ -2347,11 +2299,10 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=330,
                 )
 
-        gr.HTML('<div class="section-rule">Non-additivity / interaction decomposition</div>')
+        gr.HTML('<div class="section-rule">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."
+            "Compare the joint ablation with the sum of individual effects.",
+            elem_classes=["section-note"],
         )
         interaction_target = gr.Textbox(label="Target continuation for interaction test", value="2x")
         interaction_btn = gr.Button("Run individual-vs-joint decomposition", variant="primary", elem_classes=["action-btn"])
@@ -2386,12 +2337,11 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
         gr.HTML('<div class="section-rule">Decoder geometry</div>')
         with gr.Group():
             gr.Markdown(
-                "Joint causal effects can reflect both **decoder-direction geometry** and downstream non-linearity. "
-                "This zero-extra-generation diagnostic measures pairwise decoder cosines and compares the actual "
-                "activation-weighted joint-ablation norm with the norm expected for independent directions."
+                "Decoder-vector cosines and joint-edit geometry.",
+                elem_classes=["section-note"],
             )
             geometry_btn = gr.Button(
-                "Inspect selected-feature geometry", variant="primary", elem_classes=["action-btn"]
+                "Inspect decoder geometry", variant="primary", elem_classes=["action-btn"]
             )
             geometry_metrics = gr.Markdown()
             with gr.Row(equal_height=False):
@@ -2420,19 +2370,16 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                         height=320,
                     )
 
-    with gr.Tab("Feature evidence"):
+    with gr.Tab("Features"):
         gr.Markdown(
-            "### Feature activation evidence\n"
-            "Inspect **where a feature fires inside the current prompt**, then test whether it activates preferentially "
-            "across FeatureLens's seven controlled concept groups. The concept scan uses the feature's **maximum "
-            "activation across non-padding tokens in each prompt**, avoiding arbitrary final-token comparisons."
+            "## Feature evidence\n"
+            "Discover concept-associated candidates, screen causal effects, then inspect individual features in context.",
+            elem_classes=["guide-intro"],
         )
-        gr.HTML('<div class="section-rule">A. Concept-guided candidate discovery</div>')
+        gr.HTML('<div class="section-rule">Candidate discovery</div>')
         gr.Markdown(
-            "Start from a concept instead of an anonymous feature id. The default **Balanced selectivity** ranking "
-            "downweights globally high-activation features and favors candidates that are both selective and consistently "
-            "active for the target concept. The table also checks whether each candidate is active in the current Workbench "
-            "prompt and selected token, so you can tell whether it is immediately usable for a causal test."
+            "Rank SAE features from the controlled prompt set. **Causal-ready at current token** keeps only candidates active at the selected Workbench location.",
+            elem_classes=["section-note"],
         )
         with gr.Row(equal_height=True):
             discovery_concept = gr.Dropdown(
@@ -2455,10 +2402,10 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 scale=2,
             )
             gr.Markdown(
-                "**Input source:** controlled concept prompts + the current Workbench prompt/token, evaluated in the same GPU batch.",
-                elem_classes=["instrument-note"],
+                "Controlled prompts and the selected Workbench location share one batch.",
+                elem_classes=["section-note"],
             )
-        discovery_btn = gr.Button("Discover concept-associated candidates", variant="primary", elem_classes=["action-btn"])
+        discovery_btn = gr.Button("Rank candidates", variant="primary", elem_classes=["action-btn"])
         discovery_metrics = gr.Markdown()
         with gr.Row(equal_height=False):
             with gr.Column(scale=3):
@@ -2477,22 +2424,20 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     buttons=["fullscreen", "export"], elem_classes=["fl-plot"], height=330
                 )
         gr.Markdown(
-            "Click a row in **Candidate feature evidence** to place that feature in the selector below. "
-            "The selector defaults to the highest-ranked candidate active at the current Workbench token when available.",
+            "Click a row to select that feature.",
             elem_classes=["candidate-help"],
         )
         with gr.Row(equal_height=True):
             discovery_candidate = gr.Dropdown(choices=[], label="Selected candidate feature id", allow_custom_value=True, scale=3)
             use_candidate_btn = gr.Button(
-                "Use selected candidate across feature tests", variant="primary", elem_classes=["action-btn"], scale=2
+                "Use selected feature", variant="secondary", elem_classes=["copy-btn"], scale=2
             )
         candidate_use_status = gr.Markdown()
 
-        gr.HTML('<div class="section-rule">B. Batched causal candidate triage</div>')
+        gr.HTML('<div class="section-rule">Candidate triage</div>')
         gr.Markdown(
-            "Use discovery candidates as a short list, then ablate several of them in **one batched scoring run**. "
-            "This ranks target effects cheaply before you spend a full 8-random-control causal test on a feature. "
-            "Uses the current Workbench prompt/token and the discovery layer."
+            "Ablate several candidates in one batch before spending random controls on a smaller shortlist.",
+            elem_classes=["section-note"],
         )
         with gr.Row(equal_height=True):
             candidate_screen_ids = gr.Dropdown(
@@ -2512,7 +2457,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 scale=2,
             )
         candidate_screen_btn = gr.Button(
-            "Screen candidate ablations", variant="primary", elem_classes=["action-btn"]
+            "Screen ablations", variant="primary", elem_classes=["action-btn"]
         )
         candidate_screen_metrics = gr.Markdown()
         with gr.Row(equal_height=False):
@@ -2545,15 +2490,13 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=330,
                 )
         gr.Markdown(
-            "Click a row in **Candidate ablation screen** to move that feature into **Selected candidate feature id**, "
-            "then use the existing handoff button above if you want it copied into the deeper feature tests.",
+            "Click a row to select that feature.",
             elem_classes=["candidate-help"],
         )
 
         gr.Markdown("#### Association vs causal influence")
         gr.Markdown(
-            "Computed from the discovery table and the ablation screen above — **no additional GPU call**. "
-            "It compares concept-evidence rank with target-effect and distribution-shift ranks for the same shortlist.",
+            "Discovery rank versus target-effect and distribution-shift rank for the same shortlist.",
             elem_classes=["candidate-help"],
         )
         candidate_alignment_metrics = gr.Markdown()
@@ -2594,9 +2537,8 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
 
         gr.Markdown("#### Controlled candidate specificity")
         gr.Markdown(
-            "Follow the cheap triage with a small random-controlled comparison. FeatureLens automatically proposes a "
-            "three-feature shortlist that preserves the disagreement between discovery, target-effect, and distribution-shift "
-            "rankings. Each candidate receives its own 8-direction norm-matched random ensemble in one batched forward."
+            "Up to three candidates, each with its own eight-direction norm-matched random ensemble.",
+            elem_classes=["section-note"],
         )
         with gr.Row(equal_height=True):
             candidate_specificity_ids = gr.Dropdown(
@@ -2616,7 +2558,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 scale=2,
             )
         candidate_specificity_btn = gr.Button(
-            "Run controlled candidate comparison", variant="primary", elem_classes=["action-btn"]
+            "Run controlled comparison", variant="primary", elem_classes=["action-btn"]
         )
         candidate_specificity_metrics = gr.Markdown()
         with gr.Row(equal_height=False):
@@ -2654,8 +2596,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
 
         gr.Markdown("#### Controlled evidence patterns")
         gr.Markdown(
-            "Zero-GPU synthesis of the controlled table above. It distinguishes target-weighted effects from broader "
-            "distribution-shift effects without pretending that eight-control tail values are conventional significance tests.",
+            "Compact reading of target versus distributional specificity.",
             elem_classes=["candidate-help"],
         )
         controlled_pattern_metrics = gr.Markdown()
@@ -2674,8 +2615,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
 
         gr.Markdown("#### Association vs controlled causality")
         gr.Markdown(
-            "Computed from concept discovery and the random-controlled comparison above. This is the stronger live version "
-            "of the association-vs-causality diagnostic because each candidate is normalized against its own matched-control ensemble.",
+            "Concept evidence versus random-normalized causal specificity for the same candidates.",
             elem_classes=["candidate-help"],
         )
         controlled_alignment_metrics = gr.Markdown()
@@ -2714,10 +2654,10 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=330,
                 )
 
-        gr.HTML('<div class="section-rule">C. Cross-target causal profile</div>')
+        gr.HTML('<div class="section-rule">Cross-target profile</div>')
         gr.Markdown(
-            "Use the controlled shortlist to test whether a native SAE ablation is concentrated on one exact continuation "
-            "or moves several alternatives. This is a cheap target-profile screen: no random controls are spent here."
+            "Profile the same native ablation across several exact continuations; random controls are not used in this screen.",
+            elem_classes=["section-note"],
         )
         with gr.Row(equal_height=True):
             cross_target_ids = gr.Dropdown(
@@ -2738,7 +2678,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 scale=2,
             )
         cross_target_btn = gr.Button(
-            "Run cross-target causal profile", variant="primary", elem_classes=["action-btn"]
+            "Profile target effects", variant="primary", elem_classes=["action-btn"]
         )
         cross_target_metrics = gr.Markdown()
         with gr.Row(equal_height=False):
@@ -2759,7 +2699,8 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 cross_target_plot = gr.BarPlot(
                     x="Target continuation",
                     y="Δ mean log p/token",
-                    color="Feature",
+                    color="Series",
+                    color_map={"Feature A": INK_TEAL, "Feature B": INK_UMBER, "Feature C": INK_PLUM},
                     title="Candidate effect across exact continuations",
                     elem_id="plot-cross-target-profile",
                     x_title="Target continuation",
@@ -2783,9 +2724,8 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
 
         gr.Markdown("#### Pairwise target preference shifts")
         gr.Markdown(
-            "Derived from the same cross-target scores with **no additional model call**. For each feature, "
-            "Δ(A−B) = Δ mean log p/token(A) − Δ mean log p/token(B), so positive values mean the ablation shifts "
-            "token-normalized preference toward A relative to B."
+            "From the same target scores. Positive Δ(A−B) shifts normalized preference toward A.",
+            elem_classes=["section-note"],
         )
         with gr.Row(equal_height=False):
             with gr.Column(scale=3):
@@ -2805,7 +2745,8 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 cross_target_pairwise_plot = gr.BarPlot(
                     x="Target pair",
                     y="Δ normalized preference A−B",
-                    color="Feature",
+                    color="Series",
+                    color_map={"Feature A": INK_TEAL, "Feature B": INK_UMBER, "Feature C": INK_PLUM},
                     title="Pairwise target preference shifts",
                     elem_id="plot-cross-target-pairwise",
                     x_title="Target pair",
@@ -2816,10 +2757,8 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=330,
                 )
 
-        gr.HTML('<div class="section-rule">D. Inspect one feature</div>')
-        contrast_location = gr.Markdown(
-            "**Activation trace uses the current Workbench prompt.** The controlled concept scan below uses its own balanced prompt set."
-        )
+        gr.HTML('<div class="section-rule">Inspect one feature</div>')
+        contrast_location = gr.Markdown("", visible=False)
         with gr.Row(equal_height=True):
             contrast_feature_id = gr.Dropdown(
                 choices=[],
@@ -2842,12 +2781,12 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 scale=2,
             )
 
-        gr.Markdown("### Activation trace across the current Workbench prompt")
+        gr.Markdown("### Activation trace")
         gr.Markdown(
-            "Uses the prompt currently entered in **Workbench** and shows exactly which prompt tokens include the "
-            "selected feature in the SAE TopK support."
+            "Activation of the selected feature across prompt tokens.",
+            elem_classes=["section-note"],
         )
-        trace_btn = gr.Button("Trace feature across prompt tokens", variant="primary", elem_classes=["action-btn"])
+        trace_btn = gr.Button("Trace feature", variant="primary", elem_classes=["action-btn"])
         trace_metrics = gr.Markdown()
         with gr.Row(equal_height=False):
             with gr.Column(scale=3):
@@ -2875,16 +2814,15 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=320,
                 )
 
-        gr.HTML('<div class="section-rule">E. Completion-cue sensitivity</div>')
+        gr.HTML('<div class="section-rule">Completion-cue sensitivity</div>')
         gr.Markdown(
-            "Feature 22632 in the current math example fires only on the final `is` token. This scan tests whether a "
-            "selected feature responds to **completion cues themselves** rather than the underlying concept. Enter a stem "
-            "and one cue per line; FeatureLens appends each cue and measures the feature at the final token."
+            "Final-token response to alternative completion cues.",
+            elem_classes=["section-note"],
         )
         with gr.Row(equal_height=True):
             cue_stem = gr.Textbox(label="Prompt stem", value="The derivative of x squared", lines=2, scale=3)
             cue_text = gr.Textbox(label="Completion cues (one per line)", value="is\n=\n:\nequals\ntherefore", lines=5, scale=2)
-        cue_btn = gr.Button("Run completion-cue scan", variant="primary", elem_classes=["action-btn"])
+        cue_btn = gr.Button("Compare completion cues", variant="primary", elem_classes=["action-btn"])
         cue_metrics = gr.Markdown()
         with gr.Row(equal_height=False):
             with gr.Column(scale=3):
@@ -2899,10 +2837,10 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     buttons=["fullscreen", "export"], elem_classes=["fl-plot"], height=320
                 )
 
-        gr.HTML('<div class="section-rule">F. Cue × context specificity</div>')
+        gr.HTML('<div class="section-rule">Cue × context specificity</div>')
         gr.Markdown(
-            "The single-stem cue scan can tell you that a feature prefers `is`, but not whether that preference is lexical "
-            "or context-sensitive. This matrix crosses several prompt stems with the same completion cues in one batch."
+            "Cross the same cues with unrelated prompt stems.",
+            elem_classes=["section-note"],
         )
         with gr.Row(equal_height=True):
             cue_context_stems = gr.Textbox(
@@ -2917,7 +2855,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 lines=5,
                 scale=2,
             )
-        cue_context_btn = gr.Button("Run cue × context scan", variant="primary", elem_classes=["action-btn"])
+        cue_context_btn = gr.Button("Run cue × context", variant="primary", elem_classes=["action-btn"])
         cue_context_metrics = gr.Markdown()
         with gr.Row(equal_height=False):
             with gr.Column(scale=3):
@@ -2954,9 +2892,9 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=340,
                 )
 
-        gr.HTML('<div class="section-rule">G. Controlled concept contrast for selected feature</div>')
-        gr.Markdown("### Prompt-wide controlled concept contrast")
-        contrast_btn = gr.Button("Run controlled concept contrast", variant="primary", elem_classes=["action-btn"])
+        gr.HTML('<div class="section-rule">Controlled concept contrast</div>')
+        gr.Markdown("Prompt-wide max activation across the controlled concept set.", elem_classes=["section-note"])
+        contrast_btn = gr.Button("Compare concepts", variant="primary", elem_classes=["action-btn"])
         contrast_metrics = gr.Markdown()
         with gr.Row(equal_height=False):
             with gr.Column(scale=3):
@@ -2984,12 +2922,11 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=330,
                 )
 
-    with gr.Tab("Paraphrase robustness"):
+    with gr.Tab("Paraphrases"):
         gr.Markdown(
-            "### 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. FeatureLens 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."
+            "## Paraphrase robustness\n"
+            "Compare selected-token features with prompt-wide max-pooled SAE profiles.",
+            elem_classes=["guide-intro"],
         )
         with gr.Row():
             para_a = gr.Textbox(
@@ -3011,7 +2948,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
             para_idx_a = gr.Number(value=-1, precision=0, label="Original prompt token index")
             para_idx_b = gr.Number(value=-1, precision=0, label="Paraphrase token index")
             para_top_n = gr.Slider(5, 20, value=12, step=1, label="Displayed active features")
-        para_btn = gr.Button("Compare paraphrase representations", variant="primary", elem_classes=["action-btn"])
+        para_btn = gr.Button("Compare representations", variant="primary", elem_classes=["action-btn"])
         with gr.Row():
             with gr.Column():
                 gr.Markdown("#### Original prompt tokens")
@@ -3046,10 +2983,11 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=330,
                 )
 
-    with gr.Tab("Layer trajectory"):
+    with gr.Tab("Layers"):
         gr.Markdown(
-            "### 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."
+            "## Layer trajectory\n"
+            "Compare reconstruction and sparse-activation structure across the selected early, middle, and late SAE layers.",
+            elem_classes=["guide-intro"],
         )
         with gr.Row():
             trajectory_prompt = gr.Textbox(
@@ -3097,7 +3035,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=330,
                 )
 
-    with gr.Tab("Offline study"):
+    with gr.Tab("Study"):
         gr.Markdown(STUDY.overview_markdown())
         gr.Markdown(STUDY.readiness_markdown(), elem_classes=["small-note"])
 
@@ -3163,8 +3101,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
             )
         else:
             gr.Markdown(
-                "The public study tables and figures appear automatically after the small offline artifacts "
-                "are generated and committed. No placeholder scientific numbers are shown."
+                "Run the offline study to populate measured tables and figures. Until then, this tab stays intentionally empty."
             )
 
     with gr.Tab("Method"):

docs/COLAB.md

@@ -0,0 +1,95 @@
+# Running the FeatureLens offline study on Google Colab
+
+This guide is for the **offline empirical study**, not the public Hugging Face Space. The Space remains the interactive demo; Colab is only used to produce the study artifacts once.
+
+The easiest route is the included notebook:
+
+`notebooks/FeatureLens_Offline_Study_Colab.ipynb`
+
+## What the run does
+
+The full study executes:
+
+1. build/verify the 224-prompt discovery set and 28 causal tasks;
+2. collect Qwen3 residuals and prompt-wide Qwen-Scope SAE activations at layers 4, 14, and 26;
+3. fit/evaluate held-out SAE-feature classifiers and the dense residual probe;
+4. run single-feature random-controlled causal interventions;
+5. run 1/3/5 feature-set interventions and controls;
+6. compute candidate-selection stability, study synthesis, figures, and report;
+7. validate that the publishable artifacts are complete and methodologically compatible.
+
+## Recommended runtime
+
+Use an NVIDIA GPU runtime. A 16 GB T4 is the practical baseline; an L4 or A100 gives more headroom. The notebook detects GPU memory and defaults activation collection to batch size 8 below 20 GB VRAM and 16 otherwise.
+
+Runtime varies with Colab allocation, downloads, and prompt lengths. For planning, budget roughly **1–2 hours on a T4** for a first complete run, including model/SAE downloads; faster GPUs can be substantially quicker. Treat this as a planning estimate, not a benchmark.
+
+## Persistence model
+
+Colab VMs are temporary. The notebook mounts Google Drive and replaces the repo's `artifacts/` directory with a symlink to a Drive-backed directory. This means:
+
+- activation artifacts survive a runtime reset;
+- task-level causal and feature-set checkpoints survive a reset;
+- `python -m experiments.run_all --resume` can continue rather than restart completed work;
+- Hugging Face model caches remain on the Colab VM for speed and may need to be downloaded again after a new runtime.
+
+The causal and feature-set stages checkpoint after every completed task in v0.15. Completion-marker files are runtime bookkeeping and are excluded from the publishable bundle.
+
+## Notebook configuration
+
+At the top of the notebook set:
+
+```python
+REPO_URL = "PASTE_YOUR_GIT_REPO_URL_HERE"
+BRANCH = "main"
+DRIVE_RUN_NAME = "FeatureLens_offline_v015"
+```
+
+`REPO_URL` can be the public Git URL of the Hugging Face Space repository or another Git mirror containing the same FeatureLens source.
+
+If your default branch is not `main`, change `BRANCH`.
+
+## If activation collection runs out of memory
+
+The notebook chooses a conservative batch size automatically. If CUDA still runs out of memory, rerun the pipeline cell with:
+
+```bash
+python -m experiments.run_all --resume --activation-batch-size 4
+```
+
+Changing the activation batch size changes memory/time trade-offs, not the experiment definition.
+
+## After the run
+
+The notebook runs:
+
+```bash
+python -m scripts.validate_artifacts
+```
+
+and creates a small archive containing only the publishable study outputs. It excludes:
+
+- `artifacts/activations/`;
+- `.complete` checkpoint markers;
+- model/SAE caches;
+- temporary files.
+
+Extract the archive over the local FeatureLens repository so the files land under `artifacts/`, then run the normal local release checks and push. The public **Study** tab will read those measured artifacts automatically.
+
+## Publishable outputs
+
+The bundle is expected to contain files such as:
+
+- `artifacts/feature_catalog.csv`
+- `artifacts/layer_metrics.csv`
+- `artifacts/stability.csv`
+- `artifacts/selection_stability.csv`
+- `artifacts/causal_results.csv`
+- `artifacts/feature_set_results.csv`
+- `artifacts/study_feature_summary.csv`
+- `artifacts/study_summary.json`
+- `artifacts/summary.json`
+- `artifacts/report.md`
+- `artifacts/figures/*.png`
+
+Do not commit the `artifacts/activations/` directory.

docs/OFFLINE_STUDY.md

@@ -17,7 +17,7 @@ The collector also saves `features_final_layer{layer}.npz` so local final-token
 ## Full pipeline
 
 ```bash
-python experiments/run_all.py
+python -m experiments.run_all
 ```
 
 Stages:
@@ -35,7 +35,7 @@ Stages:
 ## Resume after interruption
 
 ```bash
-python experiments/run_all.py --resume
+python -m experiments.run_all --resume
 ```
 
 The runner checks expected stage outputs and skips completed stages. This is intended for preemptible or quota-limited GPU sessions.
@@ -45,7 +45,7 @@ The runner checks expected stage outputs and skips completed stages. This is int
 After activation and causal inference artifacts exist:
 
 ```bash
-python experiments/run_analysis_only.py
+python -m experiments.run_analysis_only
 ```
 
 This reruns feature evaluation, candidate stability, study synthesis, figures, report generation, and artifact validation without another model forward pass.
@@ -75,3 +75,21 @@ This reruns feature evaluation, candidate stability, study synthesis, figures, r
 - JS specificity asks a different question from target specificity: a feature can reshape the local distribution without specifically controlling the chosen target.
 - Cross-concept correlations have n=7 and are descriptive.
 - Large activation caches should not be committed to the repository.
+
+## Colab workflow
+
+A ready-to-run Colab notebook is included at:
+
+`notebooks/FeatureLens_Offline_Study_Colab.ipynb`
+
+See [`docs/COLAB.md`](COLAB.md) for the persistence model and post-run artifact workflow. The notebook mounts Google Drive for `artifacts/`, keeps the Hugging Face model cache on the local Colab VM, selects a conservative activation batch from available VRAM, and runs the pipeline with `--resume`.
+
+v0.15 additionally checkpoints `run_causal` and `run_feature_sets` after each completed task. If a runtime ends mid-stage, the next `--resume` run skips complete tasks within that stage rather than repeating the entire causal or feature-set benchmark.
+
+The full runner also accepts:
+
+```bash
+python -m experiments.run_all --resume --activation-batch-size 8 --activation-max-length 192
+```
+
+These two activation flags only affect memory/time during activation collection.

docs/VALIDATION.md

@@ -1,10 +1,10 @@
-# FeatureLens v0.14 validation
+# FeatureLens v0.15 validation
 
-v0.14 changes the **offline study path and Offline study tab**. It does not change the live Qwen/SAE intervention callbacks validated in v0.13, so do not spend ZeroGPU quota rerunning paraphrase, dose-response, controlled specificity, cross-target, layer trajectory, or feature-set regressions.
+v0.15 is a **public-design and offline-runner hardening release**. It does not change the already validated live Qwen/SAE inference methods. Do not spend ZeroGPU quota rerunning causal, paraphrase, layer, cue, discovery, or feature-set experiments for this release.
 
-## A. Local release gate
+## Local software gate
 
-From the repository root:
+Run from the repository root:
 
 ```bash
 python3 -m pytest -q && \
@@ -14,50 +14,70 @@ python3 scripts/ui_smoke.py && \
 python3 scripts/release_check.py
 ```
 
-Expected automated test count for v0.14: **74**.
+Then validate the Colab notebook JSON:
 
-## B. HF acceptance — zero GPU calls
+```bash
+python3 - <<'PY'
+import nbformat
+nb = nbformat.read('notebooks/FeatureLens_Offline_Study_Colab.ipynb', as_version=4)
+nbformat.validate(nb)
+print('Colab notebook: PASS')
+PY
+```
 
-After pushing v0.14:
+## Hugging Face acceptance — no GPU calls
 
-1. Open the Space and confirm startup is clean.
-2. Open **Offline study**.
-3. Before real artifacts are committed, verify it says **Offline study not materialized yet** and does not show fabricated tables or metrics.
-4. Confirm the rest of the live tabs render normally. Do not run GPU experiments solely for this release.
+After pushing, only inspect the rendered interface.
 
-## C. Offline-study synthetic/software acceptance
+### A. Header and navigation
 
-The automated suite covers:
+Pass when:
 
-- prompt-wide max pooling while ignoring padding;
-- balanced candidate score behavior;
-- random-ensemble pairing by causal task;
-- descriptive Spearman guardrails;
-- offline-study missing/complete UI state.
+- the header shows **FeatureLens** and one factual subtitle;
+- there is no visible release/version badge;
+- tabs read **Guide, Workbench, Feature sets, Features, Paraphrases, Layers, Study, Method**;
+- tabs are visually flat rather than pill/card navigation.
 
-The development integration gate additionally runs the CPU evaluation/stability/study/report stack on synthetic saved activations and validates the resulting artifact schema.
+### B. Guide
 
-## D. Real offline-study acceptance
+Open **Guide**.
 
-When a CUDA run is available:
+Pass when:
 
-```bash
-python experiments/run_all.py --resume
-```
+- there is no three-card “step 1 / step 2 / step 3” onboarding grid;
+- the workflow is short prose;
+- headings use the serif display face while controls/body copy use the neutral sans-serif face;
+- no gradients, glow, badge clusters, or decorative cards are visible.
 
-Then:
+### C. Workbench without running inference
 
-```bash
-python -m scripts.validate_artifacts
-```
+Open **Workbench**.
+
+Pass when:
+
+- experiment sections have a clear typographic hierarchy;
+- related fields sit close together and separate experiments have more breathing room;
+- primary experiment buttons are compact muted-teal actions, not full-width desktop banners;
+- **Copy TSV** is visually secondary;
+- table titles are clearly larger than table body text;
+- no duplicate context cards appear inside the tab—the global **Context** line is the context source of truth.
+
+### D. Features tab without running inference
+
+Open **Features**.
+
+Pass when:
+
+- discovery, triage, controlled comparison, cross-target profile, and feature diagnostics read as sections of one tool rather than nested cards;
+- helper copy is short and does not repeatedly restate “not a semantic label” after every empty result;
+- the page remains usable in both normal desktop width and a narrower browser window.
+
+### E. Study empty state
+
+Open **Study** before real artifacts are committed.
 
-Required checks:
+Pass when it clearly says the offline study is not materialized and does not show fabricated metrics or placeholder result plots.
 
-- activation metadata says `prompt-wide max activation across non-padding tokens`;
-- `features_layer4/14/26.npz` exist for prompt-wide concept evidence;
-- `features_final_layer4/14/26.npz` exist for local final-token diagnostics;
-- `feature_catalog.csv`, `selection_stability.csv`, `causal_results.csv`, `feature_set_results.csv`, `study_feature_summary.csv`, `study_summary.json`, `summary.json`, and `report.md` are non-empty;
-- report figures include `association_vs_causality.png` and `candidate_stability.png`;
-- no large activation/model files are staged for Git.
+## Colab runner dry check
 
-After committing only the small study artifacts, restart the Space and verify **Offline study** automatically displays the measured study summary, selected-feature table, stability table, layer diagnostics, and figures.
+Do not run the full model study merely to validate v0.15. Open the included notebook in Colab and execute only the first GPU-detection cell if desired. The full study should be started only when you are ready to produce the actual empirical artifacts.

experiments/run_all.py

@@ -17,14 +17,32 @@ def parse_args() -> argparse.Namespace:
         action='store_true',
         help='Skip stages whose expected outputs already exist.',
     )
+    parser.add_argument(
+        '--activation-batch-size',
+        type=int,
+        default=16,
+        help='Batch size used only by experiments.collect_activations.',
+    )
+    parser.add_argument(
+        '--activation-max-length',
+        type=int,
+        default=192,
+        help='Maximum prompt length used only by experiments.collect_activations.',
+    )
     return parser.parse_args()
 
 
-def run(module: str, *, outputs: list[Path], resume: bool) -> None:
+def run(
+    module: str,
+    *,
+    outputs: list[Path],
+    resume: bool,
+    extra_args: list[str] | None = None,
+) -> None:
     if resume and outputs and all(path.exists() for path in outputs):
         print(f'\nSKIP {module}: expected outputs already exist.', flush=True)
         return
-    command = [sys.executable, '-m', module]
+    command = [sys.executable, '-m', module, *(extra_args or [])]
     print('\n$', ' '.join(command), flush=True)
     subprocess.run(command, cwd=ROOT, check=True)
 
@@ -47,6 +65,10 @@ def main() -> None:
             *[activation_dir / f'features_final_layer{layer}.npz' for layer in SETTINGS.layers],
         ],
         resume=args.resume,
+        extra_args=[
+            '--batch-size', str(args.activation_batch_size),
+            '--max-length', str(args.activation_max_length),
+        ],
     )
     run(
         'experiments.evaluate_features',
@@ -58,15 +80,22 @@ def main() -> None:
         ],
         resume=args.resume,
     )
+    causal_output = artifact_dir / 'causal_results.csv'
     run(
         'experiments.run_causal',
-        outputs=[artifact_dir / 'causal_results.csv'],
+        outputs=[causal_output, causal_output.with_suffix(causal_output.suffix + '.complete')],
         resume=args.resume,
+        extra_args=['--resume'] if args.resume else None,
     )
+    feature_set_output = artifact_dir / 'feature_set_results.csv'
     run(
         'experiments.run_feature_sets',
-        outputs=[artifact_dir / 'feature_set_results.csv'],
+        outputs=[
+            feature_set_output,
+            feature_set_output.with_suffix(feature_set_output.suffix + '.complete'),
+        ],
         resume=args.resume,
+        extra_args=['--resume'] if args.resume else None,
     )
     run(
         'experiments.analyze_stability',

experiments/run_causal.py

@@ -22,9 +22,39 @@ def parse_args() -> argparse.Namespace:
     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)
+    parser.add_argument(
+        '--resume',
+        action='store_true',
+        help='Resume from task-level rows already checkpointed in --output.',
+    )
     return parser.parse_args()
 
 
+
+
+def _completion_marker(path: Path) -> Path:
+    return path.with_suffix(path.suffix + '.complete')
+
+
+def _write_rows_atomic(path: Path, rows: list[dict]) -> None:
+    if not rows:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + '.tmp')
+    with temporary.open('w', newline='', encoding='utf-8') as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
+        writer.writeheader()
+        writer.writerows(rows)
+    temporary.replace(path)
+
+
+def _load_checkpoint_rows(path: Path) -> list[dict]:
+    if not path.exists():
+        return []
+    with path.open(newline='', encoding='utf-8') as handle:
+        return list(csv.DictReader(handle))
+
+
 def load_selected_features(path: Path) -> dict[str, dict]:
     with path.open(newline='', encoding='utf-8') as handle:
         rows = list(csv.DictReader(handle))
@@ -136,8 +166,28 @@ def main() -> None:
         top_k=SETTINGS.sae_top_k,
     )
 
-    results: list[dict] = []
+    marker = _completion_marker(args.output)
+    if args.resume:
+        results: list[dict] = _load_checkpoint_rows(args.output)
+    else:
+        results = []
+        args.output.unlink(missing_ok=True)
+        marker.unlink(missing_ok=True)
+
+    expected_rows_per_task = 2 * (1 + int(args.random_controls))
+    completed_counts: dict[str, int] = {}
+    for row in results:
+        task_id = str(row.get('task_id', ''))
+        completed_counts[task_id] = completed_counts.get(task_id, 0) + 1
+
     for task_idx, task in enumerate(tasks):
+        task_id = str(task['id'])
+        if args.resume and completed_counts.get(task_id, 0) == expected_rows_per_task:
+            print(f"SKIP causal task {task_idx + 1}/{len(tasks)}: {task_id}", flush=True)
+            continue
+        if args.resume and completed_counts.get(task_id, 0):
+            results = [row for row in results if str(row.get('task_id', '')) != task_id]
+
         concept = task['concept']
         choice = selected[concept]
         layer = int(choice['layer'])
@@ -284,13 +334,11 @@ def main() -> None:
                     'top1_changed': int(modified_top1 != baseline_top1),
                 }
             )
+        _write_rows_atomic(args.output, results)
         print(f"Causal task {task_idx + 1}/{len(tasks)}: {concept}", flush=True)
 
-    args.output.parent.mkdir(parents=True, exist_ok=True)
-    with args.output.open('w', newline='', encoding='utf-8') as handle:
-        writer = csv.DictWriter(handle, fieldnames=list(results[0].keys()))
-        writer.writeheader()
-        writer.writerows(results)
+    _write_rows_atomic(args.output, results)
+    marker.write_text('complete\n', encoding='utf-8')
     print(f'Wrote {len(results)} causal intervention rows to {args.output}')
 
 

experiments/run_feature_sets.py

@@ -27,9 +27,39 @@ def parse_args() -> argparse.Namespace:
     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)
+    parser.add_argument(
+        '--resume',
+        action='store_true',
+        help='Resume from task-level rows already checkpointed in --output.',
+    )
     return parser.parse_args()
 
 
+
+
+def _completion_marker(path: Path) -> Path:
+    return path.with_suffix(path.suffix + '.complete')
+
+
+def _write_rows_atomic(path: Path, rows: list[dict]) -> None:
+    if not rows:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + '.tmp')
+    with temporary.open('w', newline='', encoding='utf-8') as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
+        writer.writeheader()
+        writer.writerows(rows)
+    temporary.replace(path)
+
+
+def _load_checkpoint_rows(path: Path) -> list[dict]:
+    if not path.exists():
+        return []
+    with path.open(newline='', encoding='utf-8') as handle:
+        return list(csv.DictReader(handle))
+
+
 def hidden_from_output(output):
     return output[0] if isinstance(output, tuple) else output
 
@@ -123,11 +153,31 @@ def main() -> None:
         top_k=SETTINGS.sae_top_k,
     )
 
-    results: list[dict] = []
+    marker = _completion_marker(args.output)
+    if args.resume:
+        results: list[dict] = _load_checkpoint_rows(args.output)
+    else:
+        results = []
+        args.output.unlink(missing_ok=True)
+        marker.unlink(missing_ok=True)
+
+    completed_counts: dict[str, int] = {}
+    for row in results:
+        task_id = str(row.get('task_id', ''))
+        completed_counts[task_id] = completed_counts.get(task_id, 0) + 1
+
     for task_idx, task in enumerate(tasks):
         concept = task['concept']
         layer = int(selected[concept]['layer'])
         candidate_ids = [int(x) for x in selected[concept]['feature_ids']]
+        valid_sizes = [size for size in sizes if size <= len(candidate_ids)]
+        expected_rows = len(valid_sizes) * (1 + int(args.random_controls))
+        task_id = str(task['id'])
+        if args.resume and completed_counts.get(task_id, 0) == expected_rows:
+            print(f"SKIP feature-set task {task_idx + 1}/{len(tasks)}: {task_id}", flush=True)
+            continue
+        if args.resume and completed_counts.get(task_id, 0):
+            results = [row for row in results if str(row.get('task_id', '')) != task_id]
         sae = sae_store.get(layer)
         prompt_inputs = tokenizer(task['prompt'], return_tensors='pt', truncation=True, max_length=192)
         prompt_inputs = {key: value.to(device) for key, value in prompt_inputs.items()}
@@ -152,7 +202,6 @@ def main() -> None:
         residual = capture['hidden'][0, prompt_len - 1]
         encoding = sae.encode(residual)
 
-        valid_sizes = [size for size in sizes if size <= len(candidate_ids)]
         condition_meta: list[tuple[int, str, int, list[int], torch.Tensor]] = []
         for size in valid_sizes:
             feature_ids = candidate_ids[:size]
@@ -234,13 +283,11 @@ def main() -> None:
                     ),
                 }
             )
+        _write_rows_atomic(args.output, results)
         print(f"Feature-set task {task_idx + 1}/{len(tasks)}: {concept}", flush=True)
 
-    args.output.parent.mkdir(parents=True, exist_ok=True)
-    with args.output.open('w', newline='', encoding='utf-8') as handle:
-        writer = csv.DictWriter(handle, fieldnames=list(results[0].keys()))
-        writer.writeheader()
-        writer.writerows(results)
+    _write_rows_atomic(args.output, results)
+    marker.write_text('complete\n', encoding='utf-8')
     print(f'Wrote {len(results)} feature-set rows to {args.output}')
 
 

notebooks/FeatureLens_Offline_Study_Colab.ipynb

@@ -0,0 +1,295 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3ca18c70",
+   "metadata": {},
+   "source": [
+    "# FeatureLens offline study\n",
+    "\n",
+    "This notebook runs the full FeatureLens empirical study on a CUDA runtime while persisting experiment artifacts to Google Drive. It is designed to be resumable after Colab disconnects.\n",
+    "\n",
+    "**Before running:** choose a GPU runtime in Colab, then execute the cells from top to bottom."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dd012fdd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 1. Verify that Colab actually assigned a GPU.\n",
+    "import subprocess, sys\n",
+    "\n",
+    "subprocess.run([\"nvidia-smi\"], check=True)\n",
+    "\n",
+    "try:\n",
+    "    import torch\n",
+    "    assert torch.cuda.is_available(), \"CUDA is not available. Change the Colab runtime to a GPU and reconnect.\"\n",
+    "    props = torch.cuda.get_device_properties(0)\n",
+    "    gpu_name = torch.cuda.get_device_name(0)\n",
+    "    gpu_vram_gb = props.total_memory / 1024**3\n",
+    "    print(f\"\\nGPU: {gpu_name} | VRAM: {gpu_vram_gb:.1f} GB\")\n",
+    "except Exception as exc:\n",
+    "    raise RuntimeError(\"A CUDA GPU runtime is required for the model stages.\") from exc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bdac04b1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 2. Mount Google Drive so completed experiment stages survive a runtime reset.\n",
+    "from google.colab import drive\n",
+    "drive.mount(\"/content/drive\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0446d7cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 3. Configuration — edit REPO_URL before running this cell.\n",
+    "from pathlib import Path\n",
+    "\n",
+    "REPO_URL = \"PASTE_YOUR_GIT_REPO_URL_HERE\"\n",
+    "BRANCH = \"main\"\n",
+    "DRIVE_RUN_NAME = \"FeatureLens_offline_v015\"\n",
+    "\n",
+    "REPO_DIR = Path(\"/content/FeatureLens\")\n",
+    "DRIVE_ROOT = Path(\"/content/drive/MyDrive\") / DRIVE_RUN_NAME\n",
+    "DRIVE_ARTIFACTS = DRIVE_ROOT / \"artifacts\"\n",
+    "LOG_PATH = DRIVE_ROOT / \"offline_study.log\"\n",
+    "\n",
+    "if REPO_URL.startswith(\"PASTE_\"):\n",
+    "    raise ValueError(\"Set REPO_URL to your FeatureLens Git repository URL first.\")\n",
+    "\n",
+    "DRIVE_ARTIFACTS.mkdir(parents=True, exist_ok=True)\n",
+    "print(\"Persistent run directory:\", DRIVE_ROOT)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c305468e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 4. Clone or refresh the FeatureLens source.\n",
+    "import shutil, subprocess\n",
+    "\n",
+    "if not REPO_DIR.exists():\n",
+    "    subprocess.run([\"git\", \"clone\", \"--branch\", BRANCH, \"--single-branch\", REPO_URL, str(REPO_DIR)], check=True)\n",
+    "else:\n",
+    "    subprocess.run([\"git\", \"-C\", str(REPO_DIR), \"fetch\", \"origin\", BRANCH], check=True)\n",
+    "    subprocess.run([\"git\", \"-C\", str(REPO_DIR), \"checkout\", BRANCH], check=True)\n",
+    "    subprocess.run([\"git\", \"-C\", str(REPO_DIR), \"pull\", \"--ff-only\", \"origin\", BRANCH], check=True)\n",
+    "\n",
+    "print(subprocess.check_output([\"git\", \"-C\", str(REPO_DIR), \"rev-parse\", \"--short\", \"HEAD\"], text=True).strip())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e34c567a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 5. Install the project environment. This can take a few minutes on a fresh runtime.\n",
+    "import subprocess, sys\n",
+    "subprocess.run([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"-r\", str(REPO_DIR / \"requirements.txt\")], check=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "501273c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 6. Re-check CUDA after dependency installation and choose a conservative activation batch.\n",
+    "import os, torch\n",
+    "\n",
+    "assert torch.cuda.is_available(), \"CUDA disappeared after dependency setup.\"\n",
+    "gpu_name = torch.cuda.get_device_name(0)\n",
+    "gpu_vram_gb = torch.cuda.get_device_properties(0).total_memory / 1024**3\n",
+    "ACTIVATION_BATCH_SIZE = 16 if gpu_vram_gb >= 20 else 8\n",
+    "ACTIVATION_MAX_LENGTH = 192\n",
+    "\n",
+    "# Keep model/SAE downloads on Colab's local disk for speed.\n",
+    "os.environ[\"HF_HOME\"] = \"/content/hf_cache\"\n",
+    "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n",
+    "\n",
+    "print(f\"GPU: {gpu_name} ({gpu_vram_gb:.1f} GB)\")\n",
+    "print(f\"Activation batch size: {ACTIVATION_BATCH_SIZE}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "41a3a0e8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 7. Link FeatureLens artifacts to Google Drive.\n",
+    "# Existing small repo artifacts (for example README.md) are copied once; the local directory is then replaced by a symlink.\n",
+    "import shutil\n",
+    "\n",
+    "local_artifacts = REPO_DIR / \"artifacts\"\n",
+    "if local_artifacts.is_symlink():\n",
+    "    local_artifacts.unlink()\n",
+    "elif local_artifacts.exists():\n",
+    "    shutil.copytree(local_artifacts, DRIVE_ARTIFACTS, dirs_exist_ok=True)\n",
+    "    shutil.rmtree(local_artifacts)\n",
+    "\n",
+    "local_artifacts.symlink_to(DRIVE_ARTIFACTS, target_is_directory=True)\n",
+    "print(\"artifacts ->\", local_artifacts.resolve())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dbfda9e4",
+   "metadata": {},
+   "source": [
+    "## Run / resume the study\n",
+    "\n",
+    "The command below is safe to rerun. Completed stages are skipped. The causal and feature-set stages also checkpoint completed tasks, so a disconnect during either stage does not discard earlier tasks from that stage."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f0bfd41",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 8. Run the full pipeline with live output and a persistent log.\n",
+    "import subprocess, sys, time\n",
+    "\n",
+    "command = [\n",
+    "    sys.executable, \"-m\", \"experiments.run_all\",\n",
+    "    \"--resume\",\n",
+    "    \"--activation-batch-size\", str(ACTIVATION_BATCH_SIZE),\n",
+    "    \"--activation-max-length\", str(ACTIVATION_MAX_LENGTH),\n",
+    "]\n",
+    "\n",
+    "print(\"$\", \" \".join(command))\n",
+    "print(\"Log:\", LOG_PATH)\n",
+    "start = time.time()\n",
+    "\n",
+    "with LOG_PATH.open(\"a\", encoding=\"utf-8\") as log:\n",
+    "    log.write(\"\\n\\n=== FeatureLens run ===\\n\")\n",
+    "    log.write(\"$ \" + \" \".join(command) + \"\\n\")\n",
+    "    process = subprocess.Popen(\n",
+    "        command, cwd=REPO_DIR, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1\n",
+    "    )\n",
+    "    assert process.stdout is not None\n",
+    "    for line in process.stdout:\n",
+    "        print(line, end=\"\")\n",
+    "        log.write(line)\n",
+    "        log.flush()\n",
+    "    return_code = process.wait()\n",
+    "\n",
+    "if return_code != 0:\n",
+    "    raise RuntimeError(\n",
+    "        f\"Pipeline exited with code {return_code}. Fix the error, then rerun this cell; --resume will keep completed work.\"\n",
+    "    )\n",
+    "\n",
+    "print(f\"\\nCompleted in {(time.time() - start) / 60:.1f} minutes.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "645d7ee5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 9. Validate the measured artifact set.\n",
+    "import subprocess, sys\n",
+    "subprocess.run([sys.executable, \"-m\", \"scripts.validate_artifacts\"], cwd=REPO_DIR, check=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9e823e4d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 10. Inspect the study summary and report.\n",
+    "from pathlib import Path\n",
+    "import json, pandas as pd\n",
+    "from IPython.display import display, Markdown\n",
+    "\n",
+    "summary_path = DRIVE_ARTIFACTS / \"study_summary.json\"\n",
+    "study_table_path = DRIVE_ARTIFACTS / \"study_feature_summary.csv\"\n",
+    "report_path = DRIVE_ARTIFACTS / \"report.md\"\n",
+    "\n",
+    "summary = json.loads(summary_path.read_text(encoding=\"utf-8\"))\n",
+    "display(summary)\n",
+    "display(pd.read_csv(study_table_path))\n",
+    "display(Markdown(report_path.read_text(encoding=\"utf-8\")))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62c96dc6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 11. Create a small publishable artifact bundle (activation caches and checkpoint markers are excluded).\n",
+    "import zipfile\n",
+    "\n",
+    "PUBLISH_ZIP = DRIVE_ROOT / \"FeatureLens_offline_results.zip\"\n",
+    "\n",
+    "with zipfile.ZipFile(PUBLISH_ZIP, \"w\", compression=zipfile.ZIP_DEFLATED) as zf:\n",
+    "    for path in sorted(DRIVE_ARTIFACTS.rglob(\"*\")):\n",
+    "        if not path.is_file():\n",
+    "            continue\n",
+    "        rel = path.relative_to(DRIVE_ARTIFACTS)\n",
+    "        if rel.parts and rel.parts[0] == \"activations\":\n",
+    "            continue\n",
+    "        if path.name.endswith(\".complete\") or path.name.endswith(\".tmp\"):\n",
+    "            continue\n",
+    "        zf.write(path, arcname=str(Path(\"artifacts\") / rel))\n",
+    "\n",
+    "print(\"Publishable bundle:\", PUBLISH_ZIP)\n",
+    "print(f\"Size: {PUBLISH_ZIP.stat().st_size / 1024**2:.2f} MiB\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a6634bfe",
+   "metadata": {},
+   "source": [
+    "## After Colab\n",
+    "\n",
+    "Download `FeatureLens_offline_results.zip` from the Drive run folder. Extract it over your local FeatureLens repository so the files land under `artifacts/`, run the normal release checks locally, inspect the measured report, and only then commit the small study artifacts. Do **not** commit `artifacts/activations/`."
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "name": "FeatureLens Offline Study",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

pyproject.toml

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

research_config.json

@@ -90,7 +90,7 @@
     "contrastive_continuation_preference_test",
     "feature_decoder_geometry"
   ],
-  "concept_candidate_discovery_metric": "balanced exploratory score = selectivity \u00d7 target activation rate \u00d7 log1p(target mean); causal-ready mode additionally requires current-token activity and log-scales that activation; raw mean-difference remains available as a scale-sensitive comparison",
+  "concept_candidate_discovery_metric": "balanced exploratory score = selectivity × target activation rate × log1p(target mean); causal-ready mode additionally requires current-token activity and log-scales that activation; raw mean-difference remains available as a scale-sensitive comparison",
   "completion_cue_scan": "final-token feature activation after controlled suffix/cue substitution",
   "live_features_v0_6": [
     "start_here_plain_language_onboarding",
@@ -196,5 +196,14 @@
     "resume_safe_full_study_runner",
     "cpu_only_analysis_rerun",
     "offline_artifact_schema_validation"
+  ],
+  "ui_and_runner_features_v0_15": [
+    "project_design_contract",
+    "flat_research_instrument_visual_system",
+    "dual_typeface_hierarchy",
+    "concise_data_first_result_copy",
+    "muted_cross_target_chart_series",
+    "colab_offline_runner_notebook",
+    "task_level_causal_and_feature_set_resume"
   ]
 }

scripts/release_check.py

@@ -10,6 +10,7 @@ MAX_FILE_SIZE_BYTES = 5_000_000  # 5 MB
 
 REQUIRED = [
     'README.md',
+    'DESIGN.md',
     'app.py',
     'requirements.txt',
     'research_config.json',
@@ -29,6 +30,8 @@ REQUIRED = [
     'data/causal_tasks.jsonl',
     'docs/VALIDATION.md',
     'docs/OFFLINE_STUDY.md',
+    'docs/COLAB.md',
+    'notebooks/FeatureLens_Offline_Study_Colab.ipynb',
     'scripts/ui_smoke.py',
     'tests/test_offline_study.py',
     'scripts/validate_artifacts.py',
@@ -254,6 +257,22 @@ def check_config(config: dict) -> None:
             'research_config.json offline_features_v0_14 mismatch: '
             f'{sorted(actual_offline_v14)}'
         )
+
+    required_v15 = {
+        'project_design_contract',
+        'flat_research_instrument_visual_system',
+        'dual_typeface_hierarchy',
+        'concise_data_first_result_copy',
+        'muted_cross_target_chart_series',
+        'colab_offline_runner_notebook',
+        'task_level_causal_and_feature_set_resume',
+    }
+    actual_v15 = set(config.get('ui_and_runner_features_v0_15', []))
+    if actual_v15 != required_v15:
+        raise SystemExit(
+            'research_config.json ui_and_runner_features_v0_15 mismatch: '
+            f'{sorted(actual_v15)}'
+        )
     if config.get('offline_selection_resamples') != 128:
         raise SystemExit('Offline selection resamples must be 128.')
     if 'prompt-wide' not in str(config.get('offline_feature_pooling', '')):
@@ -320,60 +339,29 @@ def check_readme() -> None:
         'sdk: gradio',
         'sdk_version: "6.24.0"',
         'Qwen/Qwen3-1.7B-Base',
-        'full-continuation',
-        'feature-set',
-        'paraphrase',
-        'random-control ensemble',
-        'batched zero-edit',
-        'concept contrast',
-        'non-additivity',
-        'contrastive',
-        'decoder geometry',
-        'token activation',
-        'concept-guided candidate',
-        'completion-cue',
-        'cue × context',
-        'balanced selectivity',
-        'german',
-        'start here',
-        'causal-ready',
-        'cue-dominant',
-        'batched causal candidate triage',
-        'in-place',
-        'gpu',
-        'discovery–causality alignment',
-        'spearman',
-        'rank-shift',
-        'no additional gpu',
-        'controlled candidate specificity',
-        'norm-matched random ensemble',
-        'association vs controlled causality',
-        'target-specificity ratio',
-        'js-specificity ratio',
-        'controlled evidence patterns',
-        'split-half',
-        'cross-target',
-        'target-profile',
-        'resample shortlist support',
-        'pairwise target preference',
-        'effect concentration',
-        'signed bias',
+        'Qwen-Scope',
+        'random controls',
         'prompt-wide',
         'offline study',
-        'selection stability',
-        'run_analysis_only',
-        '--resume',
+        '-m experiments.run_all --resume',
+        '--activation-batch-size',
         'validate_artifacts',
+        'FeatureLens_Offline_Study_Colab.ipynb',
+        'DESIGN.md',
     ]
     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.14 content: {missing}')
+        raise SystemExit(f'README.md is missing required v0.15 content: {missing}')
+
+    # Public README should not lead with release-train marketing. Version history belongs in CHANGELOG.
+    if '> **v0.' in readme or '## v0.' in readme:
+        raise SystemExit('README.md should not contain visible release-announcement/version-history sections.')
 
 
 def check_pyproject() -> None:
     text = (ROOT / 'pyproject.toml').read_text(encoding='utf-8')
-    if 'version = "0.14.0"' not in text:
-        raise SystemExit('pyproject.toml must declare version 0.14.0.')
+    if 'version = "0.15.0"' not in text:
+        raise SystemExit('pyproject.toml must declare version 0.15.0.')
 
 
 def main() -> None:
@@ -391,7 +379,7 @@ def main() -> None:
     print(f'  layers: {config["layers"]}')
     print(f'  feature-set sizes: {config["feature_set_sizes"]}')
     print(f'  random controls: {config["live_random_controls"]}')
-    print('  release: v0.14.0')
+    print('  release: v0.15.0')
 
 
 if __name__ == '__main__':

tests/test_design_system.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+APP = (ROOT / 'app.py').read_text(encoding='utf-8')
+DESIGN = (ROOT / 'DESIGN.md').read_text(encoding='utf-8')
+
+
+def test_design_contract_is_present_and_specific():
+    assert 'research instrument' in DESIGN.lower()
+    assert 'no gradients' in DESIGN.lower()
+    assert 'nested-card' in DESIGN.lower() or 'nested cards' in DESIGN.lower()
+    assert 'Segoe UI' in DESIGN
+    assert 'Georgia' in DESIGN
+    assert 'Copy TSV' in DESIGN
+
+
+def test_public_ui_avoids_common_generated_frontend_tells():
+    lowered = APP.lower()
+    assert 'linear-gradient' not in lowered
+    assert 'radial-gradient' not in lowered
+    assert 'backdrop-filter' not in lowered
+    assert 'gr.accordion(' not in lowered
+    assert 'start here' not in lowered
+    assert 'unlock your' not in lowered
+    assert 'supercharge' not in lowered
+    assert 'all-in-one' not in lowered
+    assert '<h1>featurelens</h1>' in lowered
+    assert '<h1>featurelens v' not in lowered
+
+
+def test_ui_has_explicit_type_and_action_roles():
+    assert '--fl-body: "Segoe UI"' in APP
+    assert '--fl-display: Georgia' in APP
+    assert '.action-btn' in APP
+    assert '.copy-btn' in APP
+    assert 'Copy TSV' in APP
+    assert 'with gr.Tab("Features")' in APP
+
+
+def test_cross_target_charts_use_restrained_fixed_series_palette():
+    assert '"Feature A": INK_TEAL' in APP
+    assert '"Feature B": INK_UMBER' in APP
+    assert '"Feature C": INK_PLUM' in APP

tests/test_offline_resume.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import csv
+import sys
+import types
+from pathlib import Path
+
+
+def _stub_transformers() -> None:
+    if 'transformers' in sys.modules:
+        return
+    stub = types.ModuleType('transformers')
+    stub.AutoModelForCausalLM = type('AutoModelForCausalLM', (), {})
+    stub.AutoTokenizer = type('AutoTokenizer', (), {})
+    sys.modules['transformers'] = stub
+
+
+def test_run_all_forwards_activation_collection_tuning(monkeypatch, tmp_path: Path) -> None:
+    from experiments import run_all
+
+    calls: list[list[str]] = []
+
+    def fake_run(command, **_kwargs):
+        calls.append(list(command))
+        return types.SimpleNamespace(returncode=0)
+
+    monkeypatch.setattr(run_all.subprocess, 'run', fake_run)
+    missing = tmp_path / 'not-created'
+    run_all.run(
+        'experiments.collect_activations',
+        outputs=[missing],
+        resume=True,
+        extra_args=['--batch-size', '8', '--max-length', '192'],
+    )
+    assert calls
+    assert calls[0][-4:] == ['--batch-size', '8', '--max-length', '192']
+
+
+def test_causal_checkpoint_helpers_roundtrip(tmp_path: Path) -> None:
+    _stub_transformers()
+    from experiments import run_causal
+
+    output = tmp_path / 'causal_results.csv'
+    rows = [
+        {'task_id': 'task-1', 'concept': 'mathematics', 'condition': 'sae_feature'},
+        {'task_id': 'task-1', 'concept': 'mathematics', 'condition': 'random_norm_matched'},
+    ]
+    run_causal._write_rows_atomic(output, rows)
+    loaded = run_causal._load_checkpoint_rows(output)
+    assert loaded == rows
+    assert run_causal._completion_marker(output).name == 'causal_results.csv.complete'
+    assert not output.with_suffix('.csv.tmp').exists()
+
+
+def test_feature_set_checkpoint_helpers_roundtrip(tmp_path: Path) -> None:
+    _stub_transformers()
+    from experiments import run_feature_sets
+
+    output = tmp_path / 'feature_set_results.csv'
+    rows = [
+        {'task_id': 'task-1', 'set_size': '1', 'condition': 'sae_feature_set'},
+        {'task_id': 'task-1', 'set_size': '1', 'condition': 'random_norm_matched'},
+    ]
+    run_feature_sets._write_rows_atomic(output, rows)
+    with output.open(newline='', encoding='utf-8') as handle:
+        saved = list(csv.DictReader(handle))
+    assert saved == rows
+    assert run_feature_sets._load_checkpoint_rows(output) == rows
+    assert run_feature_sets._completion_marker(output).name == 'feature_set_results.csv.complete'

tests/test_ui_helpers.py

@@ -49,7 +49,7 @@ def test_use_candidate_feature_returns_explicit_handoff_status() -> None:
     outputs = app.use_candidate_feature('21885')
     assert outputs[:4] == ('21885', '21885', '21885', '21885')
     assert 'Feature 21885 loaded' in outputs[4]
-    assert 'Single-feature causal test' in outputs[4]
+    assert 'feature-level experiments' in outputs[4]
 
 
 def test_select_candidate_row_uses_feature_id_column() -> None:
@@ -106,7 +106,8 @@ def test_result_tables_hide_native_labels_in_favor_of_explicit_headings() -> Non
     assert app.discovery_table.show_label is False
     assert app.dose_table.show_label is False
     assert '.table-heading' in app.CSS
-    assert 'margin: 0 0 -34px' in app.CSS
+    assert 'margin: 2px 0 -32px' in app.CSS
+    assert 'font-size: 1.16rem' in app.CSS
 
 
 def test_candidate_screen_markdown_is_explicitly_triage_only() -> None:
@@ -122,7 +123,6 @@ def test_candidate_screen_markdown_is_explicitly_triage_only() -> None:
     text = app._candidate_screen_metrics_markdown(result)
     assert 'triage screen' in text
     assert 'no random-control ensemble is spent here' in text
-    assert 'Single-feature causal test' in text
 
 
 def test_candidate_screen_has_independent_target_and_multiselect() -> None: