Release FeatureLens v0.9.0

CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## v0.9.0
+
+### In-place focus and layout polish
+- Replaced the HF-iframe-hostile overlay/fullscreen experiment with **in-place focus** for plots and tables. The original component expands exactly where it is located; plots are scaled from their existing rendering so aspect ratio is preserved and no cloned toolbar icon can be mistaken for the chart.
+- Focus is capped by both screen width and height, and the same fullscreen toolbar icon toggles the component back without moving the page to the top.
+- Reworked explicit result-table headings into compact HTML headings that occupy the Dataframe toolbar whitespace instead of leaving a large empty band above the first row.
+- Removed the unnecessary “Standalone experiment” dose-response explanation while keeping independent feature and target fields.
+
+### Candidate-to-causality workflow
+- Added **Batched causal candidate triage**. Up to eight concept-discovery candidates are independently ablated in one batched scoring run at the current Workbench location.
+- The screen reports native activation, perturbation norm, target mean/sequence log-probability deltas, and next-token JS, and ranks candidates by absolute target effect.
+- The triage deliberately omits random controls; its purpose is to identify which candidate is worth promoting to the existing single-feature 8-direction random-control test.
+- Concept discovery now directly populates the candidate-screen multiselect, defaulting to up to five returned candidates.
+
+### GPU-budget-aware validation
+- HF acceptance no longer reruns identity paraphrase, layer trajectory, or 1/3/5 set-size sweeps when those code paths are unchanged. Automated tests cover them; scarce ZeroGPU minutes are reserved for new/touched inference paths.
+
 ## v0.8.0
 
 ### UI readability and focus

README.md

@@ -13,7 +13,7 @@ license: mit
 
 # FeatureLens — Causal Interpretability Workbench
 
-> **v0.8:** a cleaner evidence workflow with bounded plot focus, explicit table headings, standalone dose-response inputs, a causal-ready current-token candidate ranking, and data-driven cue-dominant specificity summaries—while retaining balanced/raw discovery, causal controls, robustness, geometry, and prompt-wide evidence.
+> **v0.9:** a GPU-budget-aware discovery-to-causality workflow with in-place aspect-preserving focus, compact result headings, causal-ready candidate discovery, and a batched multi-candidate ablation screen before the full random-control causal test.
 
 **Research question:**
 
@@ -97,8 +97,8 @@ The main workflow supports:
 - exact **full-continuation teacher-forced scoring**;
 - per-target-token log-probability decomposition;
 - 8-direction norm-matched random controls;
-- **standalone** batched scale dose-response with its own feature id and target continuation;
-- bounded plot focus views that do not stretch across ultrawide displays.
+- 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
 
@@ -127,12 +127,14 @@ The difference is reported as an **interaction excess**. A non-zero excess means
 
 ### Feature evidence
 
-The **Feature evidence** tab now supports four complementary live questions:
+The **Feature evidence** tab supports a discovery-to-causality workflow:
 
-1. **Concept-guided candidate discovery** — choose one of the seven controlled concept groups and rank SAE features with a selectivity-first score that combines target-vs-other contrast, target activation rate, and log activation magnitude; raw mean-difference ranking remains available for comparison. The result is a candidate list, **not a semantic label**.
-2. **Feature-token activation trace** — show exactly where a selected feature enters the SAE TopK support across every token of the current Workbench prompt.
-3. **Completion-cue sensitivity** — append controlled suffixes/cues to one prompt stem and measure the selected feature at the final token. This is useful for separating concept evidence from lexical/structural completion cues.
-4. **Prompt-wide controlled concept contrast** — evaluate one selected feature on a small balanced batch from:
+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:
 
 - code;
 - mathematics;
@@ -346,12 +348,15 @@ FeatureLens/
 └── research_config.json
 ```
 
-## v0.8 live workflow improvements
+## v0.9 live workflow improvements
 
 - **Causal-ready candidate ranking** requires concept contrast and current-token activity before suggesting a feature for immediate intervention.
-- **Standalone dose-response** has independent feature and target inputs; Section II does not need to run first.
-- **Cue × context interpretation** reports cue dominance from the measured activation matrix rather than generic boilerplate.
-- **Plot focus** uses a bounded overlay and preserves page position on close; table titles are explicit headings instead of relying on Gradio component labels.
+- **Batched causal candidate triage** screens up to eight discovered candidates in one target-scoring batch before the expensive random-control causal test.
+- **Dose response** has independent feature and target inputs with concise scale semantics.
+- **Cue × context interpretation** reports cue-dominant tested patterns from the measured activation matrix rather than generic boilerplate.
+- **In-place focus** expands plots/tables at their existing page location and preserves plot aspect ratio instead of opening an HF-iframe overlay.
+- **Compact table headings** use the Dataframe toolbar band rather than leaving a large blank gap above the table.
+- HF validation is **GPU-budget-aware**: unchanged inference paths are not rerun on every release.
 
 ## Validation
 
@@ -363,7 +368,7 @@ python scripts/ui_smoke.py
 python scripts/release_check.py
 ```
 
-See [`docs/VALIDATION.md`](docs/VALIDATION.md). The v0.8 validation guide uses the **exact labels shown in the UI**, focuses on new-version acceptance/regression tests, and intentionally defers the comprehensive adversarial suite to the final release.
+See [`docs/VALIDATION.md`](docs/VALIDATION.md). The v0.9 validation guide uses the **exact labels shown in the UI** and deliberately avoids rerunning unchanged GPU-heavy regressions. HF acceptance is limited to code paths changed in this release.
 
 ## Limitations
 

app.py

@@ -121,12 +121,16 @@ CSS = r"""
 }
 .start-card h3 { margin-top: 0; }
 .graph-note { font-size: .95rem; opacity: .72; margin-top: 2px; }
-.table-heading { margin: 4px 0 7px !important; }
-.table-heading h4, .table-heading p {
-  font-size: 1.24rem !important;
+.table-heading {
+  margin: 0 0 -34px !important;
+  padding: 4px 58px 0 0 !important;
+  min-height: 34px;
+  position: relative;
+  z-index: 3;
+  pointer-events: none;
+  font-size: 1.20rem !important;
   font-weight: 700 !important;
-  line-height: 1.28 !important;
-  margin: 0 !important;
+  line-height: 1.22 !important;
 }
 .result-table .label-wrap,
 .result-table .label-wrap span,
@@ -148,70 +152,22 @@ CSS = r"""
   font-weight: 700 !important;
   line-height: 1.25 !important;
 }
-/* Plot focus is handled by a FeatureLens overlay instead of Gradio native fullscreen.
-   The original page never moves, and the focused chart is bounded for readability. */
-#featurelens-plot-focus-overlay {
-  position: fixed;
-  inset: 0;
-  z-index: 100000;
-  background: rgba(8, 8, 8, .82);
-  display: flex;
-  align-items: flex-start;
-  justify-content: center;
-  padding: 5vh 3vw;
-  box-sizing: border-box;
-}
-.featurelens-focus-panel {
-  width: min(92vw, 1120px);
-  max-height: 90vh;
-  overflow: auto;
-  background: var(--background-fill-primary);
-  border: 1px solid var(--border-color-primary);
-  border-radius: 4px;
-  box-shadow: 0 14px 46px rgba(0, 0, 0, .45);
-  padding: 14px 18px 18px;
-}
-.featurelens-focus-toolbar {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  margin-bottom: 8px;
-}
-.featurelens-focus-title { font-size: 1.18rem; font-weight: 700; }
-.featurelens-focus-close {
-  min-width: 36px !important;
-  min-height: 32px !important;
-  background: var(--background-fill-secondary) !important;
-  color: var(--body-text-color) !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. */
+.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;
 }
-.featurelens-focus-chart {
-  width: 100%;
-  display: flex;
-  align-items: flex-start;
-  justify-content: center;
-  overflow: hidden;
-}
-.featurelens-focus-chart svg,
-.featurelens-focus-chart canvas {
-  display: block;
-  width: 100% !important;
-  max-width: 1080px !important;
-  height: auto !important;
-  max-height: 78vh !important;
-  object-fit: contain;
+.fl-plot.featurelens-inline-focus {
+  transform-origin: top left !important;
 }
-/* Keep Gradio Dataframe fullscreen available; tables genuinely benefit from width. */
-.result-table.fullscreen {
-  top: 5vh !important;
-  left: 50% !important;
-  transform: translateX(-50%) !important;
-  width: min(94vw, 1420px) !important;
-  height: 90vh !important;
-  padding: 18px 22px 24px !important;
-  border-radius: 4px !important;
-  overflow: auto !important;
-  box-shadow: 0 0 0 100vmax rgba(0, 0, 0, .66), 0 14px 40px rgba(0, 0, 0, .35) !important;
+.result-table.featurelens-inline-focus {
+  overflow: visible !important;
 }
 .candidate-help { opacity: .78; font-size: .97rem; margin-top: -2px; }
 @media (max-width: 900px) {
@@ -281,96 +237,92 @@ INSTALL_REFLOW_JS = r"""
   mutation.observe(root, {subtree: true, childList: true});
   window.__featurelens_mutation_observer = mutation;
 
-  const closePlotFocus = () => {
-    const overlay = document.getElementById("featurelens-plot-focus-overlay");
-    if (!overlay) return;
-    overlay.remove();
-    document.body.style.overflow = window.__featurelens_body_overflow || "";
-    const y = window.__featurelens_plot_scroll_y;
-    window.__featurelens_plot_scroll_y = null;
-    window.__featurelens_body_overflow = null;
-    if (y != null) window.scrollTo(0, y);
+  const restoreFocus = (block) => {
+    if (!block || !block.classList.contains("featurelens-inline-focus")) return;
+    const saved = block.__featurelens_saved_style;
+    if (saved == null || saved === "") block.removeAttribute("style");
+    else block.setAttribute("style", saved);
+    block.classList.remove("featurelens-inline-focus");
+    block.__featurelens_saved_style = null;
+    window.setTimeout(kick, 30);
   };
 
-  const readableTitle = (block) => {
-    const id = (block && block.id) || "plot-featurelens-chart";
-    return id.replace(/^plot-/, "").replace(/[-_]+/g, " ")
-      .replace(/\b\w/g, (letter) => letter.toUpperCase());
+  const closeOtherFocus = (except) => {
+    document.querySelectorAll(".featurelens-inline-focus").forEach((node) => {
+      if (node !== except) restoreFocus(node);
+    });
   };
 
-  const openPlotFocus = (block) => {
-    closePlotFocus();
-    window.__featurelens_plot_scroll_y = window.scrollY;
-    window.__featurelens_body_overflow = document.body.style.overflow || "";
-    document.body.style.overflow = "hidden";
-
-    const overlay = document.createElement("div");
-    overlay.id = "featurelens-plot-focus-overlay";
-    const panel = document.createElement("div");
-    panel.className = "featurelens-focus-panel";
-    const toolbar = document.createElement("div");
-    toolbar.className = "featurelens-focus-toolbar";
-    const title = document.createElement("div");
-    title.className = "featurelens-focus-title";
-    title.textContent = readableTitle(block);
-    const close = document.createElement("button");
-    close.className = "featurelens-focus-close";
-    close.type = "button";
-    close.setAttribute("aria-label", "Close chart focus view");
-    close.textContent = "Close";
-    toolbar.append(title, close);
-
-    const chart = document.createElement("div");
-    chart.className = "featurelens-focus-chart";
-    const sourceSvg = block.querySelector("svg");
-    const sourceCanvas = block.querySelector("canvas");
-    if (sourceSvg) {
-      const clone = sourceSvg.cloneNode(true);
-      clone.removeAttribute("width");
-      clone.removeAttribute("height");
-      chart.appendChild(clone);
-    } else if (sourceCanvas) {
-      const canvas = document.createElement("canvas");
-      canvas.width = sourceCanvas.width;
-      canvas.height = sourceCanvas.height;
-      const context = canvas.getContext("2d");
-      if (context) context.drawImage(sourceCanvas, 0, 0);
-      chart.appendChild(canvas);
-    } else {
-      const fallback = block.cloneNode(true);
-      fallback.querySelectorAll("button").forEach((node) => node.remove());
-      fallback.removeAttribute("id");
-      chart.appendChild(fallback);
+  const focusPlotInPlace = (block) => {
+    const rect = block.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0) return;
+    const viewportWidth = Math.max(320, document.documentElement.clientWidth || window.innerWidth || rect.width);
+    const screenHeight = Math.max(600, (window.screen && window.screen.availHeight) || 900);
+    const maxWidth = Math.min(viewportWidth * 0.90, 1100);
+    const maxHeight = Math.min(screenHeight * 0.68, 700);
+    const scale = Math.max(1, Math.min(maxWidth / rect.width, maxHeight / rect.height, 1.8));
+    const focusedWidth = rect.width * scale;
+    let dx = (viewportWidth - focusedWidth) / 2 - rect.left;
+    if (rect.left + dx < 12) dx += 12 - (rect.left + dx);
+    if (rect.left + dx + focusedWidth > viewportWidth - 12) {
+      dx -= (rect.left + dx + focusedWidth) - (viewportWidth - 12);
     }
-    panel.append(toolbar, chart);
-    overlay.appendChild(panel);
-    document.body.appendChild(overlay);
-    close.addEventListener("click", closePlotFocus);
-    overlay.addEventListener("click", (event) => {
-      if (event.target === overlay) closePlotFocus();
-    });
+    block.style.transformOrigin = "top left";
+    block.style.transform = `translate(${dx}px, 0px) scale(${scale})`;
+    block.style.marginBottom = `${Math.max(8, rect.height * (scale - 1) + 8)}px`;
+    block.style.zIndex = "5000";
+  };
+
+  const focusTableInPlace = (block) => {
+    const rect = block.getBoundingClientRect();
+    if (rect.width <= 0) return;
+    const viewportWidth = Math.max(320, document.documentElement.clientWidth || window.innerWidth || rect.width);
+    const targetWidth = Math.max(rect.width, Math.min(viewportWidth * 0.94, 1400));
+    let dx = (viewportWidth - targetWidth) / 2 - rect.left;
+    if (rect.left + dx < 12) dx += 12 - (rect.left + dx);
+    if (rect.left + dx + targetWidth > viewportWidth - 12) {
+      dx -= (rect.left + dx + targetWidth) - (viewportWidth - 12);
+    }
+    block.style.width = `${targetWidth}px`;
+    block.style.maxWidth = "none";
+    block.style.transform = `translateX(${dx}px)`;
+    block.style.zIndex = "5000";
+  };
+
+  const toggleInlineFocus = (block) => {
+    if (block.classList.contains("featurelens-inline-focus")) {
+      restoreFocus(block);
+      return;
+    }
+    closeOtherFocus(block);
+    block.__featurelens_saved_style = block.getAttribute("style") || "";
+    block.classList.add("featurelens-inline-focus");
+    if (block.classList.contains("fl-plot")) focusPlotInPlace(block);
+    else focusTableInPlace(block);
+    window.setTimeout(kick, 30);
   };
 
-  // Intercept Gradio's plot fullscreen button before the native handler. Native fullscreen stretches
-  // Vega plots across the monitor; FeatureLens uses a bounded, static focus copy instead.
+  // Keep the native toolbar icon, but replace Gradio fullscreen with an in-place expansion.
+  // This avoids HF iframe jumps and preserves the chart's exact rendered aspect ratio.
   document.addEventListener("click", (event) => {
     const button = event.target && event.target.closest ? event.target.closest("button") : null;
     if (!button) return;
     const label = `${button.getAttribute("aria-label") || ""} ${button.getAttribute("title") || ""} ${button.textContent || ""}`.toLowerCase();
     if (!label.includes("fullscreen")) return;
-    const plot = button.closest(".fl-plot");
-    if (!plot) return;
+    const block = button.closest(".fl-plot, .result-table");
+    if (!block) return;
     event.preventDefault();
     event.stopImmediatePropagation();
-    openPlotFocus(plot);
+    toggleInlineFocus(block);
   }, true);
 
   document.addEventListener("keydown", (event) => {
-    if (event.key === "Escape") closePlotFocus();
+    if (event.key !== "Escape") return;
+    const active = document.querySelector(".featurelens-inline-focus");
+    if (active) restoreFocus(active);
   });
 
-  // Gradio's native plot exporter currently emits chart.png. Remember which FeatureLens plot initiated
-  // the export, then rename the transient download anchor before the browser handles it.
+  // Rename Gradio's generic chart.png export without touching the export implementation.
   document.addEventListener("click", (event) => {
     const button = event.target && event.target.closest ? event.target.closest("button") : null;
     if (button) {
@@ -411,8 +363,8 @@ def _copy_button(label: str = "Copy table with headers") -> gr.Button:
     return gr.Button(label, size="sm", variant="primary", elem_classes=["copy-btn"])
 
 
-def _table_heading(text: str) -> gr.Markdown:
-    return gr.Markdown(f"#### {text}", elem_classes=["table-heading"])
+def _table_heading(text: str) -> gr.HTML:
+    return gr.HTML(f'<div class="table-heading">{text}</div>')
 
 
 def _copy_ack(_text: str) -> None:
@@ -658,6 +610,28 @@ def _discovery_metrics_markdown(result) -> str:
     )
 
 
+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}**."
+        )
+    else:
+        strongest = "No candidate rows were produced."
+    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."
+    )
+
+
 def _cue_context_metrics_markdown(result) -> str:
     active = ", ".join(
         f"{cue}: {count}/{len(result.stems)} contexts"
@@ -1199,12 +1173,72 @@ def run_concept_feature_discovery(
         choices = [str(fid) for fid in result.candidate_ids]
         default = str(result.default_candidate_id) if result.default_candidate_id is not None else (choices[0] if choices else None)
         candidate_update = gr.update(choices=choices, value=default)
-        return _discovery_metrics_markdown(result), table, chart, candidate_update, _tsv(table)
+        screen_update = gr.update(
+            choices=choices,
+            value=choices[: min(5, len(choices))],
+        )
+        return (
+            _discovery_metrics_markdown(result),
+            table,
+            chart,
+            candidate_update,
+            screen_update,
+            _tsv(table),
+        )
     except Exception as exc:
         _raise_ui_error(exc)
 
 
 
+@gpu(duration=30)
+def run_candidate_causal_screen(
+    prompt: str,
+    layer: int,
+    token_index: int,
+    feature_ids: list[str] | None,
+    target_text: str,
+):
+    try:
+        selected = [int(float(value)) for value in (feature_ids or [])]
+        result = RUNTIME.candidate_causal_screen(
+            text=prompt,
+            layer=int(layer),
+            token_index=int(token_index),
+            feature_ids=selected,
+            target_text=target_text,
+        )
+        columns = [
+            "Rank",
+            "Feature id",
+            "Native activation",
+            "Active at current token",
+            "Perturbation L2",
+            "Δ mean log p/token",
+            "Δ sequence log p",
+            "Next-token JS",
+        ]
+        table = pd.DataFrame(result.rows, columns=columns)
+        chart = pd.DataFrame(
+            result.chart_rows,
+            columns=["Feature", "Δ mean log p/token"],
+        )
+        chart["Series"] = "Candidate ablation"
+        choices = [str(feature_id) for feature_id in result.feature_ids]
+        candidate_update = gr.update(
+            choices=choices,
+            value=choices[0] if choices else None,
+        )
+        return (
+            _candidate_screen_metrics_markdown(result),
+            table,
+            chart,
+            candidate_update,
+            _tsv(table),
+        )
+    except Exception as exc:
+        _raise_ui_error(exc)
+
+
 @gpu(duration=25)
 def run_feature_cue_scan(feature_id: str, layer: int, prompt_stem: str, cue_text: str):
     try:
@@ -1286,7 +1320,7 @@ 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.8</span></h1>'
+        '<h1>FeatureLens <span style="font-size:.48em;opacity:.58;font-weight:400">v0.9</span></h1>'
         '<div class="subtitle">Causal Interpretability Workbench</div>'
         '<div class="question">Discover sparse features, test robustness, and separate correlation from causal influence.</div>'
         '</header>'
@@ -1475,14 +1509,12 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                 dose_target_text = gr.Textbox(
                     label="Dose-response target continuation",
                     value="2x",
-                    info="Independent of the Single-feature causal test target field.",
+                    info="Exact continuation scored across all dose-response conditions.",
                     scale=2,
                 )
             gr.Markdown(
-                "**Standalone experiment:** you do not need to run Section II first. This panel reads the prompt, "
-                "layer, and token fields from Section I and uses its own feature + target fields above. "
-                "Always a **scale** experiment: 0× = ablation, 1× = numerical no-edit reference, 2× = double "
-                "the native coefficient. The six conditions are evaluated together against the 1× row."
+                "0× = ablation, 1× = numerical no-edit reference, and 2× = double the native coefficient. "
+                "The six scale conditions are evaluated together against the 1× row."
             )
             dose_btn = gr.Button("Run scale dose-response", variant="primary", elem_classes=["action-btn"])
             dose_metrics = gr.Markdown()
@@ -1814,7 +1846,69 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
             )
         candidate_use_status = gr.Markdown()
 
-        gr.HTML('<div class="section-rule">B. Inspect one feature</div>')
+        gr.HTML('<div class="section-rule">B. Batched causal 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."
+        )
+        with gr.Row(equal_height=True):
+            candidate_screen_ids = gr.Dropdown(
+                choices=[],
+                value=[],
+                multiselect=True,
+                allow_custom_value=True,
+                max_choices=8,
+                label="Candidate features to screen",
+                info="Populated by concept-guided discovery; up to eight features per batch.",
+                scale=3,
+            )
+            candidate_screen_target = gr.Textbox(
+                label="Screen target continuation",
+                value="2x",
+                info="Exact continuation used only for this screening run.",
+                scale=2,
+            )
+        candidate_screen_btn = gr.Button(
+            "Screen candidate ablations", variant="primary", elem_classes=["action-btn"]
+        )
+        candidate_screen_metrics = gr.Markdown()
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=3):
+                _table_heading('Candidate ablation screen')
+                candidate_screen_table = gr.Dataframe(
+                    interactive=False,
+                    label="Candidate ablation screen",
+                    show_label=False,
+                    buttons=["fullscreen"],
+                    elem_classes=["result-table"],
+                    wrap=False,
+                    max_height=380,
+                )
+                candidate_screen_tsv = gr.Textbox(visible="hidden")
+                candidate_screen_copy = _copy_button()
+            with gr.Column(scale=2):
+                candidate_screen_plot = gr.BarPlot(
+                    x="Feature",
+                    y="Δ mean log p/token",
+                    color="Series",
+                    color_map={"Candidate ablation": INK_TEAL},
+                    title="Candidate ablation target effect",
+                    elem_id="plot-candidate-causal-screen",
+                    x_title="Feature id",
+                    y_title="Δ mean log p/token",
+                    x_label_angle=-35,
+                    buttons=["fullscreen", "export"],
+                    elem_classes=["fl-plot"],
+                    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.",
+            elem_classes=["candidate-help"],
+        )
+
+        gr.HTML('<div class="section-rule">C. 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."
         )
@@ -1873,7 +1967,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=320,
                 )
 
-        gr.HTML('<div class="section-rule">C. Completion-cue sensitivity</div>')
+        gr.HTML('<div class="section-rule">D. 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 "
@@ -1897,7 +1991,7 @@ 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">D. Cue × context specificity</div>')
+        gr.HTML('<div class="section-rule">E. 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."
@@ -1952,7 +2046,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=340,
                 )
 
-        gr.HTML('<div class="section-rule">E. Controlled concept contrast for selected feature</div>')
+        gr.HTML('<div class="section-rule">F. 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"])
         contrast_metrics = gr.Markdown()
@@ -2129,8 +2223,8 @@ Batched experiments include an explicit **zero-edit row**. Causal effects are me
 
 1. SAE reconstruction quality.
 2. Held-out feature/concept prediction.
-3. Concept-guided candidate discovery and selected-feature concept contrast.
-4. Token-local activation traces, completion-cue sensitivity, and cue × context specificity.
+3. Concept-guided candidate discovery and batched causal candidate triage.
+4. Selected-feature concept contrast and token-local activation traces, completion-cue sensitivity, and cue × context specificity.
 5. Local and prompt-wide paraphrase robustness.
 6. Single-feature causal intervention and dose-response.
 7. Contrastive continuation preference under intervention.
@@ -2229,7 +2323,31 @@ Association, robustness, geometry, and intervention evidence remain separate cla
             discovery_concept, discovery_layer, discovery_n, discovery_top_n, discovery_ranking,
             prompt, token_index,
         ],
-        outputs=[discovery_metrics, discovery_table, discovery_plot, discovery_candidate, discovery_tsv],
+        outputs=[
+            discovery_metrics,
+            discovery_table,
+            discovery_plot,
+            discovery_candidate,
+            candidate_screen_ids,
+            discovery_tsv,
+        ],
+    )
+    candidate_screen_btn.click(
+        run_candidate_causal_screen,
+        inputs=[prompt, discovery_layer, token_index, candidate_screen_ids, candidate_screen_target],
+        outputs=[
+            candidate_screen_metrics,
+            candidate_screen_table,
+            candidate_screen_plot,
+            discovery_candidate,
+            candidate_screen_tsv,
+        ],
+    )
+    candidate_screen_table.select(
+        select_candidate_row,
+        inputs=[candidate_screen_table],
+        outputs=[discovery_candidate],
+        queue=False,
     )
     discovery_table.select(
         select_candidate_row,
@@ -2278,6 +2396,7 @@ Association, robustness, geometry, and intervention evidence remain separate cla
         (trace_copy, trace_tsv),
         (contrast_copy, contrast_tsv),
         (discovery_copy, discovery_tsv),
+        (candidate_screen_copy, candidate_screen_tsv),
         (cue_copy, cue_tsv),
         (cue_context_copy, cue_context_tsv),
         (para_copy, para_tsv),

docs/METHODOLOGY.md

@@ -417,3 +417,25 @@ The log factor makes current-token presence matter without allowing a single ver
 The cue × context matrix now summarizes the measured activation pattern rather than always returning generic interpretation text. For each cue, FeatureLens counts the number of tested contexts in which the feature is active and computes mean activation across those contexts.
 
 A particularly strong tested cue-specific pattern occurs when one cue activates in every tested context and all other tested cues remain inactive. FeatureLens describes that pattern as **cue-dominant under the tested matrix**. The wording is intentionally local to the controlled stems and cues; it does not assert a universal semantic label for the SAE feature.
+
+## v0.9 batched causal candidate triage
+
+Concept-guided discovery and causal testing answer different questions. A feature can be selective for a controlled concept but have no activation at the selected Workbench token; conversely, a current-token-active feature may be causally irrelevant for the continuation under study.
+
+v0.9 therefore inserts a low-cost triage stage between discovery and the full random-control causal test. For up to eight candidate features active or inactive at the current location, FeatureLens constructs the native ablation
+
+$$
+\Delta h_i = -z_i d_i
+$$
+
+for each candidate feature $i$, stacks a zero-edit reference plus all candidate deltas along the batch dimension, and teacher-forces the same target continuation for every condition in one model forward. The screen reports:
+
+- native feature activation;
+- perturbation L2 norm;
+- target mean log-probability delta per token;
+- target sequence log-probability delta;
+- next-token Jensen-Shannon divergence.
+
+Rows are ordered by absolute target mean-log-probability effect. This ordering is deliberately a **native-ablation effect screen**, not a significance or specificity statistic. No random-control ensemble is used at this stage. A promising candidate should be promoted to the existing single-feature causal test, which compares the SAE edit with the eight-direction norm-matched random ensemble.
+
+This two-stage design reduces live GPU use while preserving the stronger causal standard for any result that is ultimately interpreted.

docs/VALIDATION.md

@@ -1,8 +1,8 @@
-# FeatureLens v0.8 validation
+# FeatureLens v0.9 validation
 
-This guide tests the v0.8 changes plus a small set of high-value regressions. Use the **exact UI labels** below. The full adversarial/edge suite remains deferred until final hardening.
+This guide intentionally **does not** ask you to rerun unchanged GPU-heavy regressions. Identity paraphrase, layer trajectory, and the 1/3/5 feature-set sweep were unchanged in v0.9 and remain covered by automated tests. Save the HF ZeroGPU quota for the two inference paths changed/added here.
 
-## 0. Local release gate
+## 1. Local release gate — no HF GPU
 
 From the repository root:
 
@@ -14,238 +14,141 @@ python3 scripts/ui_smoke.py && \
 python3 scripts/release_check.py
 ```
 
-Expected release footer:
+Expected high-level result:
 
-```text
-FeatureLens release check: PASS
-  discovery prompts: 224
-  causal tasks: 28
-  layers: [4, 14, 26]
-  feature-set sizes: [1, 3, 5]
-  random controls: 8
-  release: v0.8.0
-```
-
-## 1. Establish the canonical Workbench context
-
-Open **Workbench → I. Inspect a prompt location** and set:
-
-```text
-Prompt: The derivative of x squared is
-Residual layer: 14
-Prompt token index: -1
-Displayed active features: 12
-```
-
-Click **Inspect sparse features**.
-
-Pass conditions:
-- **Current Workbench context** reports layer 14 and token 5 (`' is'`).
-- **Strongest active SAE features** begins with feature `22632` at about `32.90625`.
-- Result-table titles such as **Strongest active SAE features** are visually larger than table body text and are not rendered as tiny native component labels.
-
-## 2. Plot focus-view regression
-
-On **Activation profile**, click the top-right fullscreen/focus icon.
-
-Pass conditions:
-- FeatureLens opens a darkened overlay with a centered chart rather than Gradio's stretched native fullscreen view.
-- The chart reading surface is bounded to roughly desktop-document width; it should not require multiple horizontal scrolls.
-- The focused chart starts at its own top.
-- Press **Close**, click the backdrop, or press **Esc**.
-- The page returns to exactly the same Workbench scroll position.
-
-Then click the export icon.
-
-Pass condition:
-- the filename is descriptive (for example `featurelens_activation-profile.png`), not `chart.png`.
-
-Repeat the focus-view check on one long-label plot such as **Cue response across contexts**.
-
-## 3. Standalone scale dose-response
+- all tests pass;
+- Ruff reports `All checks passed!`;
+- `FeatureLens UI launch smoke: PASS`;
+- release check ends with `release: v0.9.0`.
 
-Do **not** run **II. Single-feature causal test** first.
+If any command fails, stop there rather than running HF tests.
 
-Under **III. Single-feature scale dose-response**, set:
+---
 
-```text
-Dose-response feature id: 22632
-Dose-response target continuation: 2x
-```
-
-Click **Run scale dose-response**.
+# HF acceptance — only two GPU calls required
 
-Pass conditions:
-- The experiment runs without using the optional target field from Section II.
-- No `Enter a target continuation...` error occurs.
-- The 1× row is the exact numerical null:
-  - Δ feature coefficient = 0
-  - Perturbation L2 = 0
-  - Δ mean log p/token = 0
-  - Δ sequence log p = 0
-  - Next-token JS = 0
+Keep the default Workbench prompt unless stated otherwise:
 
-The expected qualitative curve from prior Qwen runs is positive under ablation and negative at stronger amplification; exact floating-point values may vary slightly.
+- **Workbench → Prompt:** `The derivative of x squared is`
+- **Workbench → Residual layer:** `14`
+- **Workbench → Prompt token index:** `-1`
 
-## 4. Candidate discovery — Balanced selectivity
+You do **not** need to run **Inspect sparse features** first for these v0.9 checks.
 
-Open **Feature evidence → A. Concept-guided candidate discovery** and set:
-
-```text
-Target concept: mathematics
-Residual layer: 14
-Prompts per concept: 4
-Candidate features: 12
-Candidate ranking: Balanced selectivity
-```
+## 2. GPU call 1 — causal-ready discovery + layout/focus test
 
-Click **Discover concept-associated candidates**.
+Go to:
 
-Pass conditions:
-- **Candidate feature evidence** has an explicit readable heading.
-- The result summary states how many displayed candidates are active at the selected Workbench token.
-- The ranking is selectivity-oriented rather than dominated by giant globally active features.
+**Feature evidence → A. Concept-guided candidate discovery**
 
-Record the top 12 rows.
+Set exactly:
 
-## 5. Candidate discovery — Causal-ready at current token
-
-Change only:
-
-```text
-Candidate ranking: Causal-ready at current token
-```
+- **Target concept:** `mathematics`
+- **Residual layer:** `14`
+- **Prompts per concept:** `4`
+- **Candidate features:** `12`
+- **Candidate ranking:** `Causal-ready at current token`
 
-Click **Discover concept-associated candidates**.
+Click:
 
-Pass conditions:
-- Every returned row has **Active at current token = True**.
-- The result summary reports `displayed/current-active = N/N`.
-- If no positively selective current-token-active feature exists, the UI reports that clearly instead of silently falling back to a prompt-wide candidate.
+**Discover concept-associated candidates**
 
-This mode is intentionally stricter than Balanced selectivity: it asks for a candidate that is both concept-associated in the live batch **and immediately ablatable at the selected Workbench token**.
+### Pass conditions
 
-## 6. Candidate discovery — Raw mean difference
+1. **Candidate feature evidence** is visually close to the table itself. There should not be a large empty band between the heading and the first table row/header.
+2. **Candidate features to screen** in section B is automatically populated with up to the first five returned candidate IDs.
+3. The discovery summary says all displayed candidates are active at the selected Workbench token for this ranking.
+4. No page jump occurs merely because results render.
 
-Change only:
+### In-place plot focus
 
-```text
-Candidate ranking: Raw mean difference
-```
+On the **Candidate evidence score** graph, click the existing fullscreen/focus toolbar icon.
 
-Click **Discover concept-associated candidates**.
+Pass if:
 
-Pass conditions:
-- large-scale features such as the previously observed `31205`, `28345`, or other globally high-activation directions may return near the top;
-- this visibly demonstrates why raw activation difference is a scale-sensitive baseline rather than the recommended discovery ranking.
+- the chart expands **where it already sits on the page**;
+- it does not jump to the top of the HF Space;
+- it remains aspect-ratio preserving rather than becoming extremely tall/long;
+- it does not require horizontal page traversal;
+- clicking the same icon again (or pressing `Esc`) returns it to the normal size without changing your surrounding page location.
 
-## 7. Candidate handoff
+### In-place table focus
 
-Return to **Balanced selectivity** or **Causal-ready at current token**.
+Click the fullscreen/focus icon on **Candidate feature evidence**.
 
-Click a row in **Candidate feature evidence**, then click:
+Pass if:
 
-**Use selected candidate across feature tests**
+- the table widens at its current location rather than opening at the top of the Space;
+- the surrounding page position is unchanged after toggling back;
+- horizontal scrolling stays inside the table when needed.
 
-Pass conditions:
-- the status message names the selected feature;
-- the feature propagates to:
-  - **Single feature id**
-  - **Dose-response feature id**
-  - **Contrastive feature id**
-  - **Feature evidence → Feature id**
-- no GPU job is launched by the handoff action itself.
+Do not rerun discovery merely to test focus. Use this already-populated output for both focus checks.
 
-## 8. Cue × context specificity for feature 22632
+---
 
-Under **Feature evidence → D. Cue × context specificity**, use:
+## 3. GPU call 2 — batched causal candidate triage
 
-```text
-Feature id: 22632
-Residual layer: 14
-Prompt stems:
-The derivative of x squared
-The capital of Germany
-The weather today
-My name
+Stay in:
 
-Completion cues:
-is
-=
-:
-equals
-therefore
-```
+**Feature evidence → B. Batched causal candidate triage**
 
-Click **Run cue × context scan**.
+The discovery run should already have populated **Candidate features to screen**. Leave the default first five candidates selected unless fewer than five were returned.
 
-Prior live evidence found `is` active in all 4 contexts and every other cue inactive. If that reproduces, pass conditions are:
-- summary explicitly calls the tested matrix a **cue-dominant pattern**;
-- `is: 4/4 contexts`;
-- all off-cue conditions remain inactive;
-- the plot uses the restrained FeatureLens cue palette rather than saturated default blue/orange/red/green colors.
+Set:
 
-Scientific interpretation: this is evidence that `22632` is much more consistent with an `is`-specific lexical/structural response under the tested matrix than with a mathematics-specific feature. It remains a controlled diagnostic, not a universal feature label.
+- **Screen target continuation:** `2x`
 
-## 9. High-value regressions
+Click:
 
-### 9a. Paraphrase identity control
+**Screen candidate ablations**
 
-Open **Paraphrase robustness** and set both text fields to:
+### Expected output
 
-```text
-The derivative of x squared is
-```
+The summary should explicitly call this a **triage screen** and explain that the full random-control ensemble is deferred to **Workbench → II. Single-feature causal test**.
 
-Use layer 14 and final token for both.
+The **Candidate ablation screen** table must contain these columns:
 
-Expected:
-- selected-token Jaccard = 1.000
-- selected-token cosine = 1.000
-- prompt-wide Jaccard = 1.000
-- prompt-wide cosine = 1.000
+- `Rank`
+- `Feature id`
+- `Native activation`
+- `Active at current token`
+- `Perturbation L2`
+- `Δ mean log p/token`
+- `Δ sequence log p`
+- `Next-token JS`
 
-### 9b. Layer trajectory
+Pass if:
 
-Open **Layer trajectory** with:
+- all selected causal-ready candidates report `Active at current token = True`;
+- rows are ordered from the largest absolute `Δ mean log p/token` to the smallest;
+- the 1st-ranked screen result is automatically placed into **Selected candidate feature id**;
+- clicking another row updates **Selected candidate feature id** without a GPU call;
+- the plot and table focus controls behave in-place as in Test 2.
 
-```text
-Prompt: The derivative of x squared is
-Prompt token index: -1
-```
+### What to send back
 
-Expected approximate regression values:
-- layer 4 cosine ≈ 0.962
-- layer 14 cosine ≈ 0.902
-- layer 26 cosine ≈ 0.961
+For v0.9 I only need:
 
-### 9c. Feature-set sensitivity
+1. the **Candidate ablation screen** table;
+2. the triage summary;
+3. whether plot focus passed;
+4. whether table focus passed;
+5. whether heading/table spacing now looks natural.
 
-Open **Feature sets → Set-size sensitivity**.
+No paraphrase, layer-trajectory, feature-set-sweep, or dose-response reruns are required for v0.9 acceptance because those inference implementations were not changed.
 
-Set:
+---
 
-```text
-Target continuation for set-size sweep: 2x
-```
+## 4. Zero-GPU visual checks
 
-Click **Run 1/3/5-feature ablation sweep**.
+These do not require running an experiment:
 
-Pass conditions:
-- rows for k = 1, 3, 5;
-- 8 random controls per k;
-- all conditions share the batched null reference;
-- no regression to a single arbitrary random control.
+- **Workbench → III. Single-feature scale dose-response** should show its own **Dose-response feature id** and **Dose-response target continuation** fields without the old “Standalone experiment” explanation.
+- The short explanatory line should only define the 0× / 1× / 2× scale semantics.
+- Existing result-table headings should use the same compact spacing pattern throughout the app.
 
-## 10. What to send back
+---
 
-For v0.8 acceptance, send:
-1. whether the bounded plot focus view finally solves the ultrawide/stretch problem;
-2. whether closing focus returns to the same page position;
-3. whether table headings are finally readable;
-4. the **Causal-ready at current token** candidate table (or the explicit no-candidate message);
-5. the cue × context summary for `22632`;
-6. whether standalone dose response works without Section II;
-7. any unexpected regression from 9a–9c.
+# Final hardening later
 
-The comprehensive malformed-input, invalid-feature-id, long-prompt, queue, narrow-screen, and repeated-click adversarial suite is still reserved for final release hardening.
+The comprehensive adversarial suite (invalid feature IDs, long prompts, inactive-feature edge cases, rapid double clicks, mixed-language prompts, etc.) remains deferred until the live feature set is frozen. That final pass should be done once, not on every iteration.

featurelens/runtime.py

@@ -243,6 +243,18 @@ class ConceptFeatureDiscoveryResult:
     displayed_current_active_count: int
 
 
+@dataclass
+class CandidateCausalScreenResult:
+    feature_ids: list[int]
+    target_tokens: list[str]
+    rows: list[list[object]]
+    chart_rows: list[list[object]]
+    active_feature_count: int
+    candidate_count: int
+    execution_drift_mean_logprob: float
+    execution_drift_js: float
+
+
 @dataclass
 class FeatureCueScanResult:
     feature_id: int
@@ -1991,6 +2003,134 @@ class FeatureLensRuntime:
             displayed_current_active_count=sum(bool(row[-1]) for row in table_rows),
         )
 
+    @torch.inference_mode()
+    def candidate_causal_screen(
+        self,
+        text: str,
+        layer: int,
+        token_index: int,
+        feature_ids: Sequence[int],
+        target_text: str,
+    ) -> CandidateCausalScreenResult:
+        """Cheaply triage several candidate features with one batched ablation screen.
+
+        This deliberately omits random controls. Its purpose is to rank candidates before
+        spending a full live causal test (with the random-control ensemble) on one or two
+        promising features. All feature ablations share the same batched zero-edit reference.
+        """
+        if not text.strip():
+            raise ValueError('Enter and inspect a Workbench prompt first.')
+        if not target_text.strip():
+            raise ValueError('Enter a target continuation for candidate causal screening.')
+        ids = list(dict.fromkeys(int(x) for x in feature_ids))
+        if not ids:
+            raise ValueError('Select at least one candidate feature to screen.')
+        if len(ids) > 8:
+            raise ValueError('Candidate causal screening supports at most eight features per run.')
+        if any(feature_id < 0 or feature_id >= self.settings.sae_width for feature_id in ids):
+            raise ValueError(f'Feature ids must be in [0, {self.settings.sae_width - 1}].')
+
+        self.ensure_ready(preload_saes=False)
+        assert self.model is not None and self.tokenizer is not None and self.sae_store is not None
+        prompt_inputs = self._inputs(text)
+        prompt_len = int(prompt_inputs['input_ids'].shape[1])
+        idx = self._resolve_index(int(token_index), prompt_len)
+        target_ids = self._target_ids(target_text)
+        full_inputs = self._append_target(prompt_inputs, target_ids)
+        sae = self.sae_store.get(int(layer))
+
+        capture: dict = {}
+        with self._capture_hook(int(layer), capture):
+            single_baseline_out = self.model(**full_inputs, use_cache=False)
+        single_logits = single_baseline_out.logits[0]
+        _, single_mean, _ = sequence_logprob_summary(
+            single_logits, prompt_length=prompt_len, target_ids=target_ids
+        )
+
+        residual = capture['hidden'][0, idx]
+        encoding = sae.encode(residual)
+        activations = [float(encoding.activation_for(feature_id)) for feature_id in ids]
+        deltas = [
+            residual_delta(
+                sae.decoder_direction(feature_id),
+                activation,
+                InterventionSpec('ablate', 0.0),
+            )
+            for feature_id, activation in zip(ids, activations, strict=True)
+        ]
+        all_deltas = torch.stack([torch.zeros_like(deltas[0]), *deltas], dim=0)
+        repeated = self._repeat_inputs(full_inputs, all_deltas.shape[0])
+        with self._batch_delta_hook(int(layer), idx, all_deltas):
+            outputs = self.model(**repeated, use_cache=False)
+
+        baseline_logits = outputs.logits[0]
+        baseline_seq, baseline_mean, _ = sequence_logprob_summary(
+            baseline_logits, prompt_length=prompt_len, target_ids=target_ids
+        )
+        baseline_next = baseline_logits[prompt_len - 1]
+        execution_drift_mean = float(baseline_mean - single_mean)
+        execution_drift_js = js_divergence_from_logits(
+            single_logits[prompt_len - 1], baseline_next
+        )
+
+        scored: list[dict[str, object]] = []
+        for row_idx, (feature_id, activation, delta) in enumerate(
+            zip(ids, activations, deltas, strict=True), start=1
+        ):
+            logits = outputs.logits[row_idx]
+            seq_logp, mean_logp, _ = sequence_logprob_summary(
+                logits, prompt_length=prompt_len, target_ids=target_ids
+            )
+            mean_delta = float(mean_logp - baseline_mean)
+            seq_delta = float(seq_logp - baseline_seq)
+            js = float(js_divergence_from_logits(baseline_next, logits[prompt_len - 1]))
+            norm = float(torch.linalg.vector_norm(delta.float()).item())
+            scored.append(
+                {
+                    'feature_id': int(feature_id),
+                    'activation': float(activation),
+                    'active': bool(activation > 0),
+                    'norm': norm,
+                    'mean_delta': mean_delta,
+                    'seq_delta': seq_delta,
+                    'js': js,
+                }
+            )
+
+        scored.sort(
+            key=lambda item: (abs(float(item['mean_delta'])), float(item['js'])),
+            reverse=True,
+        )
+        rows: list[list[object]] = []
+        chart_rows: list[list[object]] = []
+        for rank, item in enumerate(scored, start=1):
+            feature_id = int(item['feature_id'])
+            mean_delta = float(item['mean_delta'])
+            rows.append(
+                [
+                    rank,
+                    feature_id,
+                    float(item['activation']),
+                    bool(item['active']),
+                    float(item['norm']),
+                    mean_delta,
+                    float(item['seq_delta']),
+                    float(item['js']),
+                ]
+            )
+            chart_rows.append([str(feature_id), mean_delta])
+
+        return CandidateCausalScreenResult(
+            feature_ids=[int(item['feature_id']) for item in scored],
+            target_tokens=[self.tokenizer.decode([int(token_id)]) for token_id in target_ids],
+            rows=rows,
+            chart_rows=chart_rows,
+            active_feature_count=sum(bool(item['active']) for item in scored),
+            candidate_count=len(scored),
+            execution_drift_mean_logprob=execution_drift_mean,
+            execution_drift_js=float(execution_drift_js),
+        )
+
     @staticmethod
     def _cue_prompt(stem: str, cue: str) -> str:
         stem = stem.rstrip()

pyproject.toml

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

research_config.json

@@ -117,5 +117,14 @@
     "causal_ready_current_token_candidate_ranking",
     "cue_dominance_specificity_interpretation",
     "muted_cue_context_plot_palette"
+  ],
+  "candidate_causal_screen_limit": 8,
+  "candidate_causal_screen_control": "batched zero-edit reference; no random controls in triage screen",
+  "live_features_v0_9": [
+    "in_place_aspect_preserving_plot_and_table_focus",
+    "compact_table_heading_alignment",
+    "concise_independent_dose_response_copy",
+    "batched_candidate_causal_triage",
+    "gpu_budget_aware_hf_validation_scope"
   ]
 }

scripts/release_check.py

@@ -83,6 +83,7 @@ def check_config(config: dict) -> None:
         'interaction_feature_limit': 5,
         'live_geometry_feature_limit': 8,
         'concept_contrast_pooling': 'max activation across non-padding prompt tokens',
+        'candidate_causal_screen_limit': 8,
     }
     for key, value in expected.items():
         if config.get(key) != value:
@@ -165,6 +166,19 @@ def check_config(config: dict) -> None:
             'research_config.json live_features_v0_8 mismatch: ' f'{sorted(actual_live_v08)}'
         )
 
+    required_live_v09 = {
+        'in_place_aspect_preserving_plot_and_table_focus',
+        'compact_table_heading_alignment',
+        'concise_independent_dose_response_copy',
+        'batched_candidate_causal_triage',
+        'gpu_budget_aware_hf_validation_scope',
+    }
+    actual_live_v09 = set(config.get('live_features_v0_9', []))
+    if actual_live_v09 != required_live_v09:
+        raise SystemExit(
+            'research_config.json live_features_v0_9 mismatch: ' f'{sorted(actual_live_v09)}'
+        )
+
     if 'german_language' not in config.get('concepts', []) or 'french_language' in config.get('concepts', []):
         raise SystemExit('research_config.json must use german_language and must not contain french_language.')
 
@@ -238,19 +252,20 @@ def check_readme() -> None:
         'german',
         'start here',
         'causal-ready',
-        'standalone',
-        'plot focus',
         'cue-dominant',
+        'batched causal candidate triage',
+        'in-place',
+        'gpu',
     ]
     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.8 content: {missing}')
+        raise SystemExit(f'README.md is missing required v0.9 content: {missing}')
 
 
 def check_pyproject() -> None:
     text = (ROOT / 'pyproject.toml').read_text(encoding='utf-8')
-    if 'version = "0.8.0"' not in text:
-        raise SystemExit('pyproject.toml must declare version 0.8.0.')
+    if 'version = "0.9.0"' not in text:
+        raise SystemExit('pyproject.toml must declare version 0.9.0.')
 
 
 def main() -> None:
@@ -268,7 +283,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.8.0')
+    print('  release: v0.9.0')
 
 
 if __name__ == '__main__':

tests/test_live_runtime_helpers.py

@@ -323,3 +323,22 @@ def test_feature_cue_context_scan_runs_on_toy_runtime() -> None:
     assert 0 <= result.dominant_cue_context_count <= 2
     assert 0 <= result.off_dominant_active_count <= result.active_condition_count
     assert len(result.chart_rows) == 6
+
+
+def test_candidate_causal_screen_batches_multiple_ablation_candidates() -> None:
+    runtime = make_runtime()
+    result = runtime.candidate_causal_screen(
+        text='abc',
+        layer=0,
+        token_index=-1,
+        feature_ids=[0, 1, 2],
+        target_text='d',
+    )
+    assert result.candidate_count == 3
+    assert len(result.rows) == 3
+    assert len(result.chart_rows) == 3
+    assert all(len(row) == 8 for row in result.rows)
+    assert all(row[0] == rank for rank, row in enumerate(result.rows, start=1))
+    assert 0 <= result.active_feature_count <= result.candidate_count
+    assert all(math.isfinite(float(row[5])) for row in result.rows)
+    assert all(float(row[7]) >= 0 for row in result.rows)

tests/test_ui_helpers.py

@@ -64,14 +64,15 @@ def test_select_candidate_row_uses_feature_id_column() -> None:
     assert update['value'] == '445'
 
 
-def test_frontend_helpers_name_exports_and_preserve_focus_position() -> None:
+def test_frontend_helpers_name_exports_and_use_in_place_focus() -> None:
     app = _import_app()
     assert 'featurelens_${stem' in app.INSTALL_REFLOW_JS
     assert 'chart.png' in app.INSTALL_REFLOW_JS
-    assert 'featurelens-plot-focus-overlay' in app.INSTALL_REFLOW_JS
-    assert '__featurelens_plot_scroll_y' in app.INSTALL_REFLOW_JS
+    assert 'featurelens-inline-focus' in app.INSTALL_REFLOW_JS
+    assert 'toggleInlineFocus' in app.INSTALL_REFLOW_JS
     assert 'stopImmediatePropagation' in app.INSTALL_REFLOW_JS
-    assert 'window.scrollTo' in app.INSTALL_REFLOW_JS
+    assert 'featurelens-plot-focus-overlay' not in app.INSTALL_REFLOW_JS
+    assert 'window.scrollTo' not in app.INSTALL_REFLOW_JS
 
 
 def test_dose_response_has_independent_target_control() -> None:
@@ -105,3 +106,27 @@ 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
+
+
+def test_candidate_screen_markdown_is_explicitly_triage_only() -> None:
+    app = _import_app()
+    result = SimpleNamespace(
+        candidate_count=3,
+        active_feature_count=3,
+        target_tokens=['2', 'x'],
+        execution_drift_mean_logprob=1e-4,
+        execution_drift_js=2e-6,
+        rows=[[1, 16369, 29.25, True, 29.0, -0.12, -0.24, 0.004]],
+    )
+    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:
+    app = _import_app()
+    assert app.candidate_screen_target.value == '2x'
+    assert app.candidate_screen_ids.multiselect is True
+    assert app.candidate_screen_ids.max_choices == 8