Release FeatureLens v0.12.0

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## v0.12.0
+
+- Added **split-half discovery stability** using the already-computed concept activation batch, so shortlist sensitivity is visible without another GPU forward.
+- Added **Controlled evidence patterns**, a zero-GPU synthesis that distinguishes broad controlled influence, target-weighted effects, distribution-shift-dominant effects, and weak/mixed specificity while keeping eight-control tails explicitly coarse.
+- Changed **Association vs controlled causality** so missing discovery state after a Space rebuild produces an explicit explanation instead of a blank panel.
+- Added **Cross-target causal profile** for up to three candidates and five exact continuations, screening whether native ablation effects concentrate on one target or generalize across alternatives.
+- Added automatic cross-target shortlist handoff from the target-specificity and JS-specificity leaders.
+- Kept the validated in-place focus behavior unchanged.
+- Kept HF validation quota-aware: only the touched discovery path and the new cross-target path need live GPU acceptance.
+
 ## v0.11.0
 
 - Added **Controlled candidate specificity**, a one-batch follow-up that compares up to three candidate SAE ablations against each candidate's own 8-direction norm-matched random ensemble.

README.md

@@ -13,7 +13,7 @@ license: mit
 
 # FeatureLens — Causal Interpretability Workbench
 
-> **v0.11:** a controlled association-to-causality workflow that follows cheap candidate triage with per-feature norm-matched random ensembles, separating raw target effect from random-normalized causal specificity.
+> **v0.12:** a causal-evidence workflow that adds split-half discovery stability, controlled evidence-pattern synthesis, and cross-target profiling on top of random-normalized candidate specificity.
 
 **Research question:**
 
@@ -38,6 +38,9 @@ FeatureLens uses **Qwen3-1.7B-Base** with **Qwen-Scope residual-stream sparse au
 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?
 
 A high AUROC, high paraphrase overlap, or a large activation is still correlational evidence. Causal evidence comes from downstream change under controlled intervention.
@@ -368,6 +371,16 @@ FeatureLens/
 - 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.
+
 ## Validation
 
 ```bash
@@ -378,7 +391,7 @@ python scripts/ui_smoke.py
 python scripts/release_check.py
 ```
 
-See [`docs/VALIDATION.md`](docs/VALIDATION.md). The v0.11 validation guide uses the **exact labels shown in the UI** and asks for only the new controlled-candidate comparison on HF. Discovery, triage, paraphrase, trajectory, feature-set, dose-response, cue, and focus paths are not rerun because their implementations were not changed.
+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
 
@@ -394,7 +407,7 @@ See [`docs/VALIDATION.md`](docs/VALIDATION.md). The v0.11 validation guide uses
 ## Resume-ready description
 
 > **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, and norm-matched random-control ensembles.
+> 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 discovery stability, cross-target causal profiling, controlled evidence-pattern synthesis, and norm-matched random-control ensembles.
 
 ## Acknowledgements
 

app.py

@@ -598,13 +598,20 @@ def _discovery_metrics_markdown(result) -> str:
         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."
+        )
     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}  \n\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."
     )
@@ -828,6 +835,115 @@ def _candidate_specificity_metrics_markdown(result) -> str:
     )
 
 
+def _controlled_evidence_patterns(
+    specificity_table: pd.DataFrame | None,
+) -> tuple[str, pd.DataFrame]:
+    """Summarize controlled target-vs-distribution specificity without requiring discovery state."""
+    columns = [
+        "Feature id",
+        "Target specificity ratio",
+        "JS specificity ratio",
+        "Target empirical tail p",
+        "JS empirical tail p",
+        "Evidence pattern",
+        "Interpretation",
+    ]
+    if specificity_table is None:
+        return "", pd.DataFrame(columns=columns)
+    table = pd.DataFrame(specificity_table).copy()
+    needed = {
+        "Feature id",
+        "Target specificity ratio",
+        "JS specificity ratio",
+        "Target empirical tail p",
+        "JS empirical tail p",
+    }
+    if table.empty or not needed.issubset(table.columns):
+        return "", pd.DataFrame(columns=columns)
+
+    rows: list[list[object]] = []
+    for _, row in table.iterrows():
+        feature_id = int(float(row["Feature id"]))
+        target_ratio = float(row["Target specificity ratio"])
+        js_ratio = float(row["JS specificity ratio"])
+        target_p = float(row["Target empirical tail p"])
+        js_p = float(row["JS empirical tail p"])
+        if target_ratio >= 1.5 and js_ratio >= 1.5:
+            pattern = "Broad controlled influence"
+            interpretation = "Both the specified target and the local next-token distribution exceed matched-random magnitude baselines."
+        elif target_ratio >= 1.5:
+            pattern = "Target-weighted"
+            interpretation = "The specified continuation is affected more strongly than the broader distributional diagnostic."
+        elif js_ratio >= 1.5 and target_ratio < 1.0:
+            pattern = "Distribution-shift dominant"
+            interpretation = "The feature changes the local distribution beyond matched random directions without selectively controlling this target."
+        elif js_ratio >= 1.5:
+            pattern = "Distribution-shift weighted"
+            interpretation = "Distributional influence is clearer than target-specific influence for the tested continuation."
+        else:
+            pattern = "Weak / mixed specificity"
+            interpretation = "Neither live specificity ratio clearly dominates its matched-random baseline."
+        rows.append([feature_id, target_ratio, js_ratio, target_p, js_p, pattern, interpretation])
+
+    out = pd.DataFrame(rows, columns=columns)
+    descriptions = "; ".join(
+        f"**{int(row['Feature id'])}**: {row['Evidence pattern']}" for _, row in out.iterrows()
+    )
+    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."
+    )
+    return summary, out
+
+
+def _cross_target_shortlist(specificity_table: pd.DataFrame | None, limit: int = 2) -> list[str]:
+    if specificity_table is None:
+        return []
+    table = pd.DataFrame(specificity_table).copy()
+    needed = {"Feature id", "Target specificity ratio", "JS specificity ratio"}
+    if table.empty or not needed.issubset(table.columns):
+        return []
+    table["Feature id"] = pd.to_numeric(table["Feature id"], errors="coerce")
+    table = table.dropna(subset=["Feature id"]).copy()
+    table["Feature id"] = table["Feature id"].astype(int)
+    selected: list[int] = []
+
+    def add(feature_id: int) -> None:
+        if feature_id not in selected and len(selected) < int(limit):
+            selected.append(feature_id)
+
+    target = table.sort_values(["Target specificity ratio", "Feature id"], ascending=[False, True])
+    js = table.sort_values(["JS specificity ratio", "Feature id"], ascending=[False, True])
+    if not target.empty:
+        add(int(target.iloc[0]["Feature id"]))
+    if not js.empty:
+        add(int(js.iloc[0]["Feature id"]))
+    for feature_id in target["Feature id"].tolist():
+        add(int(feature_id))
+    return [str(feature_id) for feature_id in selected]
+
+
+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)
+    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}**."
+        )
+    else:
+        lead = "No cross-target rows were produced."
+    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}  \n\n"
+        "This is a **target-profile screen** using native SAE ablations and a batched no-edit reference for each continuation. "
+        "It does not spend random controls, so use Controlled candidate specificity for matched-random causal claims."
+    )
+
+
 def _controlled_alignment_outputs(
     discovery_table: pd.DataFrame | None,
     specificity_table: pd.DataFrame | None,
@@ -850,12 +966,27 @@ def _controlled_alignment_outputs(
         "JS empirical tail p",
         "Discovery→specificity rank shift",
     ]
-    if discovery_table is None or specificity_table is None:
+    if specificity_table is None:
         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.",
+            pd.DataFrame(columns=columns),
+            pd.DataFrame(),
+        )
     discovery = pd.DataFrame(discovery_table).copy()
     controlled = pd.DataFrame(specificity_table).copy()
-    if discovery.empty or controlled.empty or "Feature id" not in discovery or "Feature id" not in controlled:
+    if controlled.empty or "Feature id" not in controlled:
         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.",
+            pd.DataFrame(columns=columns),
+            pd.DataFrame(),
+        )
 
     discovery["Feature id"] = pd.to_numeric(discovery["Feature id"], errors="coerce")
     controlled["Feature id"] = pd.to_numeric(controlled["Feature id"], errors="coerce")
@@ -1624,21 +1755,84 @@ def run_candidate_specificity_screen(
             result.chart_rows,
             columns=["Feature", "Specificity metric", "Ratio"],
         )
+        pattern_metrics, pattern_table = _controlled_evidence_patterns(table)
         alignment_metrics, alignment_table, alignment_chart = _controlled_alignment_outputs(
             discovery_table, table
         )
         choices = [str(feature_id) for feature_id in result.feature_ids]
         candidate_update = gr.update(choices=choices, value=choices[0] if choices else None)
+        cross_target_values = _cross_target_shortlist(table, limit=2)
+        cross_target_update = gr.update(choices=choices, value=cross_target_values)
         return (
             _candidate_specificity_metrics_markdown(result),
             table,
             chart,
             candidate_update,
             _tsv(table),
+            pattern_metrics,
+            pattern_table,
+            _tsv(pattern_table),
             alignment_metrics,
             alignment_table,
             alignment_chart,
             _tsv(alignment_table),
+            cross_target_update,
+        )
+    except Exception as exc:
+        _raise_ui_error(exc)
+
+
+@gpu(duration=40)
+def run_candidate_cross_target_profile(
+    prompt: str,
+    layer: int,
+    token_index: int,
+    feature_ids: list[str] | None,
+    targets_text: str,
+):
+    try:
+        selected = [int(float(value)) for value in (feature_ids or [])]
+        targets = [line for line in str(targets_text).splitlines() if line.strip()]
+        result = RUNTIME.candidate_cross_target_profile(
+            text=prompt,
+            layer=int(layer),
+            token_index=int(token_index),
+            feature_ids=selected,
+            targets=targets,
+        )
+        columns = [
+            "Feature id",
+            "Target continuation",
+            "Target token count",
+            "Native activation",
+            "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=["Target continuation", "Feature", "Δ mean log p/token"],
+        )
+        summary_columns = [
+            "Feature id",
+            "Strongest target",
+            "Δ mean log p/token at strongest target",
+            "Strongest |effect|",
+            "Mean |effect| on other targets",
+            "Target-profile ratio",
+            "Effect sign pattern",
+            "Maximum next-token JS",
+        ]
+        summary_table = pd.DataFrame(result.summary_rows, columns=summary_columns)
+        return (
+            _cross_target_metrics_markdown(result),
+            table,
+            chart,
+            summary_table,
+            _tsv(table),
+            _tsv(summary_table),
         )
     except Exception as exc:
         _raise_ui_error(exc)
@@ -1725,7 +1919,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.11</span></h1>'
+        '<h1>FeatureLens <span style="font-size:.48em;opacity:.58;font-weight:400">v0.12</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>'
@@ -2415,6 +2609,26 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=330,
                 )
 
+        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.",
+            elem_classes=["candidate-help"],
+        )
+        controlled_pattern_metrics = gr.Markdown()
+        _table_heading('Controlled evidence pattern summary')
+        controlled_pattern_table = gr.Dataframe(
+            interactive=False,
+            label="Controlled evidence pattern summary",
+            show_label=False,
+            buttons=["fullscreen"],
+            elem_classes=["result-table"],
+            wrap=True,
+            max_height=300,
+        )
+        controlled_pattern_tsv = gr.Textbox(visible="hidden")
+        controlled_pattern_copy = _copy_button()
+
         gr.Markdown("#### Association vs controlled causality")
         gr.Markdown(
             "Computed from concept discovery and the random-controlled comparison above. This is the stronger live version "
@@ -2457,7 +2671,74 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=330,
                 )
 
-        gr.HTML('<div class="section-rule">C. Inspect one feature</div>')
+        gr.HTML('<div class="section-rule">C. Cross-target causal 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."
+        )
+        with gr.Row(equal_height=True):
+            cross_target_ids = gr.Dropdown(
+                choices=[],
+                value=[],
+                multiselect=True,
+                allow_custom_value=True,
+                max_choices=3,
+                label="Features for cross-target profile",
+                info="Auto-filled from the target-specificity leader and JS-specificity leader when available.",
+                scale=3,
+            )
+            cross_target_text = gr.Textbox(
+                label="Exact target continuations (one per line)",
+                value="2x\nx\n0\nx^2",
+                lines=4,
+                info="Two to five continuations. Each is teacher-forced separately.",
+                scale=2,
+            )
+        cross_target_btn = gr.Button(
+            "Run cross-target causal profile", variant="primary", elem_classes=["action-btn"]
+        )
+        cross_target_metrics = gr.Markdown()
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=3):
+                _table_heading('Cross-target causal profile')
+                cross_target_table = gr.Dataframe(
+                    interactive=False,
+                    label="Cross-target causal profile",
+                    show_label=False,
+                    buttons=["fullscreen"],
+                    elem_classes=["result-table"],
+                    wrap=False,
+                    max_height=390,
+                )
+                cross_target_tsv = gr.Textbox(visible="hidden")
+                cross_target_copy = _copy_button()
+            with gr.Column(scale=2):
+                cross_target_plot = gr.BarPlot(
+                    x="Target continuation",
+                    y="Δ mean log p/token",
+                    color="Feature",
+                    title="Candidate effect across exact continuations",
+                    elem_id="plot-cross-target-profile",
+                    x_title="Target continuation",
+                    y_title="Δ mean log p/token",
+                    buttons=["fullscreen", "export"],
+                    elem_classes=["fl-plot"],
+                    height=330,
+                )
+        _table_heading('Target-profile summary')
+        cross_target_summary_table = gr.Dataframe(
+            interactive=False,
+            label="Target-profile summary",
+            show_label=False,
+            buttons=["fullscreen"],
+            elem_classes=["result-table"],
+            wrap=False,
+            max_height=260,
+        )
+        cross_target_summary_tsv = gr.Textbox(visible="hidden")
+        cross_target_summary_copy = _copy_button()
+
+        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."
         )
@@ -2516,7 +2797,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=320,
                 )
 
-        gr.HTML('<div class="section-rule">D. Completion-cue sensitivity</div>')
+        gr.HTML('<div class="section-rule">E. 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 "
@@ -2540,7 +2821,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">E. Cue × context specificity</div>')
+        gr.HTML('<div class="section-rule">F. 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."
@@ -2595,7 +2876,7 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
                     height=340,
                 )
 
-        gr.HTML('<div class="section-rule">F. Controlled concept contrast for selected feature</div>')
+        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"])
         contrast_metrics = gr.Markdown()
@@ -2920,10 +3201,32 @@ Association, robustness, geometry, and intervention evidence remain separate cla
             candidate_specificity_plot,
             discovery_candidate,
             candidate_specificity_tsv,
+            controlled_pattern_metrics,
+            controlled_pattern_table,
+            controlled_pattern_tsv,
             controlled_alignment_metrics,
             controlled_alignment_table,
             controlled_alignment_plot,
             controlled_alignment_tsv,
+            cross_target_ids,
+        ],
+    )
+    cross_target_btn.click(
+        run_candidate_cross_target_profile,
+        inputs=[
+            prompt,
+            discovery_layer,
+            token_index,
+            cross_target_ids,
+            cross_target_text,
+        ],
+        outputs=[
+            cross_target_metrics,
+            cross_target_table,
+            cross_target_plot,
+            cross_target_summary_table,
+            cross_target_tsv,
+            cross_target_summary_tsv,
         ],
     )
     candidate_specificity_table.select(
@@ -2988,7 +3291,10 @@ Association, robustness, geometry, and intervention evidence remain separate cla
         (candidate_screen_copy, candidate_screen_tsv),
         (candidate_alignment_copy, candidate_alignment_tsv),
         (candidate_specificity_copy, candidate_specificity_tsv),
+        (controlled_pattern_copy, controlled_pattern_tsv),
         (controlled_alignment_copy, controlled_alignment_tsv),
+        (cross_target_copy, cross_target_tsv),
+        (cross_target_summary_copy, cross_target_summary_tsv),
         (cue_copy, cue_tsv),
         (cue_context_copy, cue_context_tsv),
         (para_copy, para_tsv),

docs/METHODOLOGY.md

@@ -531,3 +531,41 @@ The zero-GPU synthesis layer joins discovery evidence to the controlled table an
 - random-normalized JS-specificity rank.
 
 Descriptive Spearman correlations between candidate score and the two specificity ratios are shown only as small-sample diagnostics. The full offline benchmark remains the place for larger candidate sets, more random controls, uncertainty intervals, and formal held-out conclusions.
+
+## v0.12 split-half discovery stability and cross-target profiling
+
+### Split-half discovery stability
+
+The live concept-discovery batch already contains multiple controlled prompts per concept. v0.12 reuses those activations to form two prompt halves and independently reranks candidates under the same discovery mode. The UI reports the overlap/Jaccard of the two top-k sets. This costs no additional model inference.
+
+Because the live setting uses only a few prompts per concept, this is a **sensitivity diagnostic**, not a confidence interval or reliability claim. Low overlap means the live shortlist is sample-sensitive and should not be treated as a stable semantic ranking.
+
+### Controlled evidence patterns
+
+For every random-controlled candidate, FeatureLens keeps target specificity and whole-distribution JS specificity separate. v0.12 adds a descriptive pattern layer:
+
+- **Broad controlled influence**: both target and JS specificity ratios are at least 1.5× their matched-random means.
+- **Target-weighted**: target specificity is at least 1.5× while JS specificity is lower.
+- **Distribution-shift dominant**: JS specificity is at least 1.5× while target specificity is below 1×.
+- **Distribution-shift weighted**: JS specificity is at least 1.5× while target specificity is weaker but not below 1×.
+- **Weak / mixed specificity**: neither ratio clears the descriptive 1.5× threshold.
+
+These are effect-ratio summaries only. The live eight-control empirical tails remain coarse and are not converted into significance labels.
+
+### Cross-target causal profile
+
+A feature can have a large effect on one specified continuation without being generally causal for the underlying concept. v0.12 therefore evaluates the same native SAE ablation against several exact continuations.
+
+For each target continuation, FeatureLens computes a batched zero-edit baseline and reports:
+
+- Δ mean log probability per target token,
+- Δ full-sequence log probability,
+- next-token JS divergence.
+
+For each feature it also reports the strongest target by absolute mean-log-probability effect, the mean absolute effect on the remaining targets, and a **target-profile ratio**:
+
+\[
+R_{profile} = \frac{\max_t |\Delta \bar{\ell}_t|}{\operatorname{mean}_{u \ne t^*}|\Delta \bar{\ell}_u|}.
+\]
+
+This profile is a screening diagnostic and intentionally omits random controls. Random-normalized causal claims still require the Controlled candidate specificity experiment.

docs/VALIDATION.md

@@ -1,10 +1,10 @@
-# FeatureLens v0.11 validation
+# FeatureLens v0.12 validation
 
-v0.11 adds one new GPU inference path: **Controlled candidate specificity**. It does **not** change concept discovery, cheap candidate triage, paraphrase robustness, layer trajectory, feature-set interventions, dose response, cue diagnostics, or the validated in-place focus behavior. Do not spend ZeroGPU quota rerunning those unchanged paths.
+v0.12 touches two GPU inference paths: **concept-guided discovery** (only to add split-half stability from the same activations) and the new **cross-target causal profile**. Do not rerun unchanged experiments merely as regressions.
 
 ## Local release gate
 
-Run from the repository root:
+From the repository root:
 
 ```bash
 python3 -m pytest -q && \
@@ -14,7 +14,9 @@ python3 scripts/ui_smoke.py && \
 python3 scripts/release_check.py
 ```
 
-Expected release checker tail:
+Expected automated test count: **65 passed**.
+
+Expected release footer:
 
 ```text
 FeatureLens release check: PASS
@@ -23,20 +25,12 @@ FeatureLens release check: PASS
   layers: [4, 14, 26]
   feature-set sizes: [1, 3, 5]
   random controls: 8
-  release: v0.11.0
+  release: v0.12.0
 ```
 
-## HF acceptance: one GPU call only
-
-The v0.10 discovery and triage paths were already validated. For v0.11, test only the new controlled follow-up.
-
-### Exact path
+## HF acceptance — only two GPU calls
 
-Open **Feature evidence** and scroll to:
-
-**B. Batched causal candidate triage → Controlled candidate specificity**
-
-Use the current Workbench context:
+Use this Workbench context before both calls:
 
 ```text
 Prompt: The derivative of x squared is
@@ -44,92 +38,94 @@ Residual layer: 14
 Prompt token index: -1
 ```
 
-In **Candidates for controlled comparison**, manually enter/select exactly:
+You do not need to rerun single-feature causality, dose response, paraphrase robustness, layer trajectory, feature-set sweeps, cue diagnostics, or focus/zoom.
 
-```text
-16369
-25992
-21670
-```
+### GPU call 1 — touched discovery path
 
-These are the three strategic candidates established by the validated v0.10 workflow:
+Exact UI path:
 
-- `16369`: discovery leader and next-token-JS leader;
-- `25992`: raw target-effect leader;
-- `21670`: second-largest raw target effect.
+**Feature evidence → A. Concept-guided candidate discovery**
 
 Set:
 
 ```text
-Controlled target continuation: 2x
+Target concept: mathematics
+Residual layer: 14
+Prompts per concept: 4
+Candidate features: 12
+Candidate ranking: Causal-ready at current token
 ```
 
-Click **Run controlled candidate comparison**.
+Click:
 
-### Pass conditions
+**Discover concept-associated candidates**
 
-The run should produce **Controlled candidate specificity** with exactly three feature rows. For every row verify:
+Pass conditions:
 
-- `Active at current token` is `True`;
-- `Target specificity ratio` is finite and non-negative;
-- `Target empirical tail p` lies in `(0, 1]`;
-- `JS specificity ratio` is finite and non-negative;
-- `JS empirical tail p` lies in `(0, 1]`;
-- random-control means/stds are populated;
-- the summary says each candidate used 8 norm-matched random controls;
-- execution-context null drift is reported separately from the causal effect.
+- The normal candidate table still appears.
+- The summary includes a line beginning **Split-half shortlist stability from the same activation batch**.
+- The reported Jaccard is in `[0, 1]`.
+- The diagnostic is described as small-sample sensitivity, not semantic reliability.
 
-The plot **Random-normalized causal specificity** should show two series per feature:
+Record only the split-half shared count/Jaccard unless the candidate ranking itself changes unexpectedly.
 
-```text
-Target specificity
-JS specificity
-```
+### GPU call 2 — new cross-target causal profile
+
+Exact UI path:
+
+**Feature evidence → C. Cross-target causal profile**
 
-Do not assume which feature must win. That is the empirical result this version is intended to measure.
+Set:
+
+```text
+Features for cross-target profile:
+25992
+16369
+21670
 
-## Optional integration check — no additional GPU call
+Exact target continuations (one per line):
+2x
+x
+0
+x^2
+```
 
-If the Space still has the v0.10 discovery table populated in the same browser session, the **Association vs controlled causality** section should also populate automatically.
+Click:
 
-Verify that **Discovery–controlled-causality alignment** contains the same controlled features and includes:
+**Run cross-target causal profile**
 
-- discovery rank;
-- specificity rank;
-- target-effect rank;
-- JS-specificity rank;
-- target specificity ratio;
-- target empirical tail p;
-- JS specificity ratio;
-- JS empirical tail p;
-- discovery→specificity rank shift.
+Pass conditions:
 
-The summary may include descriptive Spearman correlations. With only three controlled candidates, these are diagnostic summaries, **not significance claims**.
+- The summary says 3 features were profiled across 4 exact continuations.
+- **Cross-target causal profile** contains `3 × 4 = 12` rows.
+- **Target-profile summary** contains one row per feature.
+- The chart contains separate feature series across the four targets.
+- No random-control/significance claim is made in this panel.
 
-If the discovery table is not populated because the Space was freshly rebuilt, do **not** spend two extra GPU calls merely to repopulate it for v0.11 acceptance. The zero-GPU join logic is covered by automated tests.
+Please return:
 
-## Do not rerun for v0.11
+1. the **Target-profile summary** table;
+2. the 12-row **Cross-target causal profile** table (or at minimum the four rows for each feature);
+3. the chart screenshot if convenient.
 
-Do not rerun these paths unless you independently notice a regression:
+## Zero-GPU behavior covered by automated tests
 
-- Concept-guided candidate discovery;
-- Batched causal candidate triage;
-- Scale dose-response;
-- Single-feature causal test;
-- Paraphrase identity control;
-- Layer trajectory;
-- 1/3/5 feature-set sweep;
-- cue sensitivity or cue × context;
-- plot/table focus behavior.
+Do not spend HF quota solely to test these:
 
-Those implementations were not changed in v0.11.
+- **Controlled evidence patterns** classifies the existing controlled specificity table without model inference.
+- If **Association vs controlled causality** has no discovery table because the Space was rebuilt, it now displays an explicit state-explanation instead of staying silently blank.
+- The cross-target selector prefers the target-specificity leader and JS-specificity leader when controlled results are present in the same session.
 
-## What to send back
+## Do not rerun for v0.12
 
-For the new controlled comparison, send:
+Unless something visibly breaks, skip:
 
-1. the three feature rows from **Controlled candidate specificity**;
-2. the summary above the table;
-3. optionally the **Association vs controlled causality** summary/table if it populated without extra GPU work.
+- identity paraphrase;
+- layer trajectory;
+- 1/3/5 feature-set sweep;
+- scale dose-response;
+- cue × context;
+- controlled candidate specificity;
+- zoom/focus behavior.
 
-That is sufficient to decide whether the live feature set should now be frozen and the project moved to the full offline benchmark.
+Those implementations are unchanged in v0.12 and remain covered by the automated suite.

featurelens/runtime.py

@@ -241,6 +241,9 @@ class ConceptFeatureDiscoveryResult:
     current_context_available: bool
     current_token_index: int | None
     displayed_current_active_count: int
+    split_half_k: int | None
+    split_half_shared_count: int
+    split_half_jaccard: float | None
 
 
 @dataclass
@@ -268,6 +271,16 @@ class CandidateSpecificityResult:
     execution_drift_js: float
 
 
+@dataclass
+class CandidateCrossTargetResult:
+    feature_ids: list[int]
+    targets: list[str]
+    rows: list[list[object]]
+    chart_rows: list[list[object]]
+    summary_rows: list[list[object]]
+    active_feature_count: int
+
+
 @dataclass
 class FeatureCueScanResult:
     feature_id: int
@@ -1937,6 +1950,65 @@ class FeatureLensRuntime:
                     include_self=True,
                 )
 
+        # Split-half stability is computed from the same controlled activation batch, so it costs no
+        # additional model inference. With very small live samples this is a diagnostic of shortlist
+        # sensitivity, not a statistical reliability estimate.
+        split_half_k: int | None = None
+        split_half_shared_count = 0
+        split_half_jaccard: float | None = None
+
+        def _rank_subset(subset_mask: torch.Tensor) -> list[int]:
+            sub_target = controlled_dense[subset_mask & target_mask]
+            sub_other = controlled_dense[subset_mask & other_mask]
+            if sub_target.shape[0] == 0 or sub_other.shape[0] == 0:
+                return []
+            sub_target_mean = sub_target.mean(dim=0)
+            sub_other_mean = sub_other.mean(dim=0)
+            sub_target_rate = (sub_target > 0).float().mean(dim=0)
+            sub_mean_diff = sub_target_mean - sub_other_mean
+            sub_selectivity = sub_mean_diff / (sub_target_mean + sub_other_mean + 1e-8)
+            sub_balanced = (
+                sub_selectivity.clamp_min(0)
+                * sub_target_rate
+                * torch.log1p(sub_target_mean.clamp_min(0))
+            )
+            sub_eligible = (sub_target_mean > 0) & (sub_mean_diff > 0)
+            if ranking_mode == 'causal_ready':
+                sub_eligible = sub_eligible & (current_token_dense > 0)
+                sub_ranking = sub_balanced * torch.log1p(current_token_dense.clamp_min(0))
+            elif ranking_mode == 'balanced_selectivity':
+                sub_ranking = sub_balanced
+            else:
+                sub_ranking = sub_mean_diff
+            sub_idx = torch.nonzero(sub_eligible, as_tuple=False).flatten()
+            if sub_idx.numel() == 0:
+                return []
+            sub_order = torch.argsort(sub_ranking[sub_idx], descending=True)
+            return [int(value.item()) for value in sub_idx[sub_order[:top_n]]]
+
+        if n >= 2:
+            half = max(1, n // 2)
+            seen_by_concept: dict[str, int] = {}
+            mask_a = torch.zeros(controlled_count, device=dense.device, dtype=torch.bool)
+            mask_b = torch.zeros_like(mask_a)
+            for row_idx, row in enumerate(rows):
+                row_concept = str(row['concept'])
+                local_idx = seen_by_concept.get(row_concept, 0)
+                seen_by_concept[row_concept] = local_idx + 1
+                if local_idx < half:
+                    mask_a[row_idx] = True
+                else:
+                    mask_b[row_idx] = True
+            ids_a = _rank_subset(mask_a)
+            ids_b = _rank_subset(mask_b)
+            if ids_a and ids_b:
+                set_a, set_b = set(ids_a), set(ids_b)
+                shared = set_a & set_b
+                union = set_a | set_b
+                split_half_k = min(len(ids_a), len(ids_b), top_n)
+                split_half_shared_count = len(shared)
+                split_half_jaccard = float(len(shared) / len(union)) if union else 1.0
+
         eligible = (target_mean > 0) & (mean_diff > 0)
         if ranking_mode == 'causal_ready':
             if not current_context_available or resolved_current_idx is None:
@@ -1966,6 +2038,9 @@ class FeatureLensRuntime:
                 current_context_available=current_context_available,
                 current_token_index=resolved_current_idx,
                 displayed_current_active_count=0,
+                split_half_k=split_half_k,
+                split_half_shared_count=split_half_shared_count,
+                split_half_jaccard=split_half_jaccard,
             )
 
         order = torch.argsort(ranking_values[candidate_idx], descending=True)
@@ -2014,6 +2089,9 @@ class FeatureLensRuntime:
             current_context_available=current_context_available,
             current_token_index=resolved_current_idx,
             displayed_current_active_count=sum(bool(row[-1]) for row in table_rows),
+            split_half_k=split_half_k,
+            split_half_shared_count=split_half_shared_count,
+            split_half_jaccard=split_half_jaccard,
         )
 
     @torch.inference_mode()
@@ -2344,6 +2422,144 @@ class FeatureLensRuntime:
             execution_drift_js=float(execution_drift_js),
         )
 
+    @torch.inference_mode()
+    def candidate_cross_target_profile(
+        self,
+        text: str,
+        layer: int,
+        token_index: int,
+        feature_ids: Sequence[int],
+        targets: Sequence[str],
+    ) -> CandidateCrossTargetResult:
+        """Profile native candidate ablations across several exact target continuations.
+
+        This is a screening diagnostic, not a random-controlled causal claim. The residual
+        representation and native feature deltas are captured once from the Workbench prompt.
+        Each target is then evaluated with one small batched forward containing the zero-edit
+        reference plus every selected candidate ablation.
+        """
+        if not text.strip():
+            raise ValueError('Enter and inspect a Workbench prompt first.')
+        ids = list(dict.fromkeys(int(x) for x in feature_ids))
+        if not ids:
+            raise ValueError('Select at least one candidate feature for cross-target profiling.')
+        if len(ids) > 3:
+            raise ValueError('Cross-target profiling supports at most three 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}].')
+
+        target_list: list[str] = []
+        seen_targets: set[str] = set()
+        for raw in targets:
+            target = str(raw)
+            if not target.strip() or target in seen_targets:
+                continue
+            seen_targets.add(target)
+            target_list.append(target)
+        if len(target_list) < 2:
+            raise ValueError('Enter at least two distinct target continuations.')
+        if len(target_list) > 5:
+            raise ValueError('Cross-target profiling supports at most five target continuations.')
+
+        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)
+        sae = self.sae_store.get(int(layer))
+
+        capture: dict = {}
+        with self._capture_hook(int(layer), capture):
+            self.model(**prompt_inputs, use_cache=False)
+        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)
+        ]
+        delta_batch = torch.stack([torch.zeros_like(residual), *deltas], dim=0)
+
+        rows: list[list[object]] = []
+        chart_rows: list[list[object]] = []
+        by_feature: dict[int, list[tuple[str, float, float]]] = {feature_id: [] for feature_id in ids}
+
+        for target_text in target_list:
+            target_ids = self._target_ids(target_text)
+            full_inputs = self._append_target(prompt_inputs, target_ids)
+            repeated = self._repeat_inputs(full_inputs, delta_batch.shape[0])
+            with self._batch_delta_hook(int(layer), idx, delta_batch):
+                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]
+            token_count = len(target_ids)
+            for output_idx, (feature_id, activation, delta) in enumerate(
+                zip(ids, activations, deltas, strict=True), start=1
+            ):
+                logits = outputs.logits[output_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]))
+                rows.append(
+                    [
+                        int(feature_id),
+                        target_text,
+                        int(token_count),
+                        float(activation),
+                        float(torch.linalg.vector_norm(delta.float()).item()),
+                        mean_delta,
+                        seq_delta,
+                        js,
+                    ]
+                )
+                chart_rows.append([target_text, str(feature_id), mean_delta])
+                by_feature[feature_id].append((target_text, mean_delta, js))
+
+        summary_rows: list[list[object]] = []
+        for feature_id in ids:
+            items = by_feature[feature_id]
+            strongest = max(items, key=lambda item: abs(item[1]))
+            strongest_abs = abs(float(strongest[1]))
+            other_abs = [abs(float(item[1])) for item in items if item is not strongest]
+            mean_other = float(sum(other_abs) / len(other_abs)) if other_abs else 0.0
+            profile_ratio = float(strongest_abs / max(mean_other, 1e-12))
+            signs = {1 if item[1] > 0 else -1 if item[1] < 0 else 0 for item in items}
+            nonzero_signs = {sign for sign in signs if sign != 0}
+            sign_consistency = 'same sign' if len(nonzero_signs) <= 1 else 'mixed signs'
+            summary_rows.append(
+                [
+                    int(feature_id),
+                    str(strongest[0]),
+                    float(strongest[1]),
+                    strongest_abs,
+                    mean_other,
+                    profile_ratio,
+                    sign_consistency,
+                    max(float(item[2]) for item in items),
+                ]
+            )
+        summary_rows.sort(key=lambda row: float(row[3]), reverse=True)
+
+        return CandidateCrossTargetResult(
+            feature_ids=ids,
+            targets=target_list,
+            rows=rows,
+            chart_rows=chart_rows,
+            summary_rows=summary_rows,
+            active_feature_count=sum(activation > 0 for activation in activations),
+        )
+
     @staticmethod
     def _cue_prompt(stem: str, cue: str) -> str:
         stem = stem.rstrip()

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "featurelens"
-version = "0.11.0"
+version = "0.12.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",
@@ -154,5 +154,20 @@
     "association_vs_controlled_causality_alignment",
     "target_specificity_vs_js_specificity_separation",
     "single_new_gpu_call_hf_acceptance"
+  ],
+  "cross_target_feature_limit": 3,
+  "cross_target_target_limit": 5,
+  "cross_target_default_targets": [
+    "2x",
+    "x",
+    "0",
+    "x^2"
+  ],
+  "live_features_v0_12": [
+    "controlled_evidence_pattern_synthesis",
+    "split_half_discovery_stability",
+    "cross_target_candidate_profile",
+    "missing_discovery_alignment_fallback",
+    "gpu_budget_aware_touched_path_validation"
   ]
 }

scripts/release_check.py

@@ -206,6 +206,21 @@ def check_config(config: dict) -> None:
             'research_config.json live_features_v0_11 mismatch: ' f'{sorted(actual_live_v11)}'
         )
 
+    required_live_v12 = {
+        'controlled_evidence_pattern_synthesis',
+        'split_half_discovery_stability',
+        'cross_target_candidate_profile',
+        'missing_discovery_alignment_fallback',
+        'gpu_budget_aware_touched_path_validation',
+    }
+    actual_live_v12 = set(config.get('live_features_v0_12', []))
+    if actual_live_v12 != required_live_v12:
+        raise SystemExit(
+            'research_config.json live_features_v0_12 mismatch: ' f'{sorted(actual_live_v12)}'
+        )
+    if config.get('cross_target_feature_limit') != 3 or config.get('cross_target_target_limit') != 5:
+        raise SystemExit('Cross-target live limits must be 3 features and 5 targets.')
+
     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.')
 
@@ -292,16 +307,20 @@ def check_readme() -> None:
         'association vs controlled causality',
         'target-specificity ratio',
         'js-specificity ratio',
+        'controlled evidence patterns',
+        'split-half',
+        'cross-target',
+        'target-profile',
     ]
     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.11 content: {missing}')
+        raise SystemExit(f'README.md is missing required v0.12 content: {missing}')
 
 
 def check_pyproject() -> None:
     text = (ROOT / 'pyproject.toml').read_text(encoding='utf-8')
-    if 'version = "0.11.0"' not in text:
-        raise SystemExit('pyproject.toml must declare version 0.11.0.')
+    if 'version = "0.12.0"' not in text:
+        raise SystemExit('pyproject.toml must declare version 0.12.0.')
 
 
 def main() -> None:
@@ -319,7 +338,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.11.0')
+    print('  release: v0.12.0')
 
 
 if __name__ == '__main__':

tests/test_live_runtime_helpers.py

@@ -363,3 +363,39 @@ def test_candidate_specificity_screen_batches_random_controlled_candidates() ->
     assert all(0 < float(row[10]) <= 1 for row in result.rows)  # empirical tail
     assert all(float(row[15]) >= 0 for row in result.rows)  # JS specificity
     assert all(0 < float(row[16]) <= 1 for row in result.rows)
+
+
+def test_concept_feature_discovery_reports_split_half_stability_without_extra_forward() -> None:
+    runtime = make_runtime()
+    result = runtime.concept_feature_discovery(
+        concept='mathematics',
+        layer=0,
+        prompts_per_concept=2,
+        top_n=3,
+        ranking_mode='balanced_selectivity',
+        current_text='abc',
+        current_token_index=-1,
+    )
+    if result.split_half_jaccard is not None:
+        assert 0.0 <= result.split_half_jaccard <= 1.0
+        assert result.split_half_k is not None
+        assert 0 <= result.split_half_shared_count <= max(len(result.candidate_ids), result.split_half_k)
+
+
+def test_candidate_cross_target_profile_runs_multiple_features_and_targets() -> None:
+    runtime = make_runtime()
+    result = runtime.candidate_cross_target_profile(
+        text='abc',
+        layer=0,
+        token_index=-1,
+        feature_ids=[0, 1],
+        targets=['d', 'e', 'f'],
+    )
+    assert result.feature_ids == [0, 1]
+    assert result.targets == ['d', 'e', 'f']
+    assert len(result.rows) == 6
+    assert len(result.chart_rows) == 6
+    assert len(result.summary_rows) == 2
+    assert all(len(row) == 8 for row in result.rows)
+    assert all(len(row) == 8 for row in result.summary_rows)
+    assert all(math.isfinite(float(row[5])) for row in result.rows)

tests/test_ui_helpers.py

@@ -256,3 +256,55 @@ def test_controlled_candidate_ui_limits_live_comparison_to_three_features() -> N
     assert app.candidate_specificity_target.value == '2x'
     assert app.candidate_specificity_table.show_label is False
     assert app.controlled_alignment_table.show_label is False
+
+
+def _v11_controlled_table() -> pd.DataFrame:
+    return pd.DataFrame(
+        [
+            [1, 25992, 21.328, True, 21.328, -0.11188, -0.01628, 0.05637, 0.06847, 1.9849, 0.3333, -0.22376, 0.001133, 0.000498, 0.000219, 2.2769, 0.1111],
+            [2, 21670, 6.359, True, 6.359, 0.02105, -0.01246, 0.01732, 0.01587, 1.2157, 0.4444, 0.04211, 0.000104, 0.000043, 0.000027, 2.4423, 0.2222],
+            [3, 16369, 29.234, True, 29.235, -0.00621, -0.00330, 0.04204, 0.04735, 0.1476, 0.8889, -0.01241, 0.001832, 0.000689, 0.000197, 2.6610, 0.1111],
+        ],
+        columns=[
+            'Rank', 'Feature id', 'Native activation', 'Active at current token', 'Perturbation L2',
+            'SAE Δ mean log p/token', 'Random signed mean Δ', 'Random mean |Δ|', 'Random |Δ| std',
+            'Target specificity ratio', 'Target empirical tail p', 'SAE Δ sequence log p',
+            'SAE next-token JS', 'Random mean JS', 'Random JS std', 'JS specificity ratio',
+            'JS empirical tail p',
+        ],
+    )
+
+
+def test_controlled_evidence_patterns_separate_target_and_distributional_influence() -> None:
+    app = _import_app()
+    summary, table = app._controlled_evidence_patterns(_v11_controlled_table())
+    patterns = dict(zip(table['Feature id'].astype(int), table['Evidence pattern'], strict=True))
+    assert patterns[25992] == 'Broad controlled influence'
+    assert patterns[21670] == 'Distribution-shift weighted'
+    assert patterns[16369] == 'Distribution-shift dominant'
+    assert 'effect ratios' in summary
+    assert 'statistical significance' in summary
+
+
+def test_controlled_alignment_explains_missing_discovery_state_instead_of_blank() -> None:
+    app = _import_app()
+    summary, table, chart = app._controlled_alignment_outputs(None, _v11_controlled_table())
+    assert 'discovery' in summary.lower()
+    assert 'browser session' in summary.lower()
+    assert table.empty
+    assert chart.empty
+
+
+def test_cross_target_shortlist_preserves_target_and_js_leaders() -> None:
+    app = _import_app()
+    selected = app._cross_target_shortlist(_v11_controlled_table(), limit=2)
+    assert selected == ['25992', '16369']
+
+
+def test_cross_target_ui_has_independent_targets_and_small_feature_limit() -> None:
+    app = _import_app()
+    assert app.cross_target_ids.multiselect is True
+    assert app.cross_target_ids.max_choices == 3
+    assert '2x' in app.cross_target_text.value
+    assert app.cross_target_table.show_label is False
+    assert app.cross_target_summary_table.show_label is False