Release FeatureLens v0.13.0

CHANGELOG.md

@@ -1,3 +1,10 @@
+## v0.13.0
+
+- Added deterministic **32-resample candidate-support diagnostics** from the same concept-discovery activation batch; each displayed feature now reports shortlist support and median resample rank without another model forward.
+- Extended cross-target profiling with **normalized effect entropy, effect concentration, signed bias, and a descriptive profile pattern** so concentrated target dependence is separated from broad same-sign behavior.
+- Added **pairwise target-preference shifts** derived from the same cross-target scores: Δ(A−B) = Δmean(A) − Δmean(B), with a table and plot and no additional inference.
+- Kept HF acceptance quota-aware: only concept discovery and cross-target profiling are touched GPU paths.
+
 # Changelog
 
 ## v0.12.0

README.md

@@ -13,7 +13,7 @@ license: mit
 
 # FeatureLens — Causal Interpretability Workbench
 
-> **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.
+> **v0.13:** a stability-and-target-selectivity release that adds deterministic resample support to live discovery and extracts effect concentration, signed bias, and pairwise target-preference shifts from the existing cross-target GPU call.
 
 **Research question:**
 
@@ -412,3 +412,21 @@ See [`docs/VALIDATION.md`](docs/VALIDATION.md). The v0.12 guide uses the **exact
 ## Acknowledgements
 
 FeatureLens builds on the open Qwen3 model and Qwen-Scope residual-stream SAE checkpoints from the Qwen team.
+
+## v0.13 stability and target-selectivity synthesis
+
+v0.13 deliberately adds **no new GPU callback**. It strengthens the two live paths already used in v0.12.
+
+### Resample shortlist support
+
+Concept-guided discovery still reports split-half Jaccard, but now also reranks the same already-computed controlled activations under **32 deterministic balanced bootstrap resamples**. Each displayed feature receives a **Resample shortlist support** fraction and **Median resample rank**. The summary reports the mean displayed support and how many candidates survive at least 75% of resampled shortlists. These are small-sample sensitivity diagnostics, not confidence intervals or held-out reliability claims.
+
+### Cross-target effect concentration
+
+The cross-target profile now separates a feature whose causal effect is concentrated on one exact continuation from one that broadly moves several alternatives. For each feature it reports **Normalized effect entropy**, **Effect concentration = 1 − entropy**, and **Signed bias = ΣΔ / Σ|Δ|**. A descriptive profile pattern labels cases such as target-concentrated/mixed-sign or broad same-sign suppression/enhancement; this label is a heuristic summary, not a semantic feature label.
+
+### Pairwise target preference
+
+Every cross-target run also derives **pairwise target preference shifts** without another forward pass. For targets A and B, FeatureLens reports `Δ(A−B) = Δ mean log p/token(A) − Δ mean log p/token(B)`. Positive values mean the SAE ablation shifts token-normalized preference toward A relative to B. This turns the same cross-target scores into a more direct comparison of alternatives while keeping the random-controlled specificity experiment separate.
+
+See [`docs/VALIDATION.md`](docs/VALIDATION.md). v0.13 requires only the two touched GPU paths: causal-ready discovery and cross-target profiling.

app.py

@@ -605,6 +605,13 @@ def _discovery_metrics_markdown(result) -> str:
             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."
         )
+    if result.resample_replicates and result.resample_mean_support is not None:
+        stability += (
+            f"  \nDeterministic balanced-resample support ({result.resample_replicates} resamples, same activations): "
+            f"mean support across displayed candidates **{result.resample_mean_support:.1%}**; "
+            f"**{result.resample_high_support_count}/{len(result.candidate_ids)}** displayed candidates appeared in at least 75% "
+            "of resampled shortlists. This is still a live small-sample stability diagnostic, not a confidence interval."
+        )
     return (
         f"Concept **{result.concept}** · layer **{result.layer}** · "
         f"{result.prompts_per_concept} prompts/concept.  \n"
@@ -933,14 +940,25 @@ def _cross_target_metrics_markdown(result) -> str:
             f"Largest screened cross-target effect: feature **{int(strongest[0])}** on **{strongest[1]!r}** "
             f"with Δ mean log p/token **{float(strongest[2]):+.4f}**."
         )
+        patterns = "; ".join(f"{int(row[0])}: {row[10]}" for row in result.summary_rows)
+        profile_text = f"  \nHeuristic target-profile patterns — {patterns}."
     else:
         lead = "No cross-target rows were produced."
+        profile_text = ""
+    pairwise_text = ""
+    if result.pairwise_rows:
+        top_pair = result.pairwise_rows[0]
+        pairwise_text = (
+            f"  \nLargest token-normalized pairwise preference shift: feature **{int(top_pair[0])}**, "
+            f"**{top_pair[1]!r} vs {top_pair[2]!r}**, Δ(A−B) **{float(top_pair[3]):+.4f}**."
+        )
     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"
+        f"{lead}{profile_text}{pairwise_text}  \n\n"
         "This is a **target-profile screen** using native SAE ablations and a batched no-edit reference for each continuation. "
-        "It does not spend random controls, so use Controlled candidate specificity for matched-random causal claims."
+        "The profile labels are descriptive heuristics, and pairwise shifts compare token-normalized target effects; neither spends "
+        "random controls. Use Controlled candidate specificity for matched-random causal claims."
     )
 
 
@@ -1626,6 +1644,8 @@ def run_concept_feature_discovery(
             "Current prompt max",
             "Current token activation",
             "Active at current token",
+            "Resample shortlist support",
+            "Median resample rank",
         ]
         table = pd.DataFrame(result.rows, columns=columns)
         chart = pd.DataFrame(result.chart_rows, columns=["Feature", "Candidate score"])
@@ -1823,16 +1843,36 @@ def run_candidate_cross_target_profile(
             "Mean |effect| on other targets",
             "Target-profile ratio",
             "Effect sign pattern",
+            "Normalized effect entropy",
+            "Effect concentration",
+            "Signed bias",
+            "Profile pattern",
             "Maximum next-token JS",
         ]
         summary_table = pd.DataFrame(result.summary_rows, columns=summary_columns)
+        pairwise_columns = [
+            "Feature id",
+            "Target A",
+            "Target B",
+            "Δ normalized preference A−B",
+            "|Preference shift|",
+            "Direction",
+        ]
+        pairwise_table = pd.DataFrame(result.pairwise_rows, columns=pairwise_columns)
+        pairwise_chart = pairwise_table.copy()
+        if not pairwise_chart.empty:
+            pairwise_chart["Target pair"] = pairwise_chart["Target A"].astype(str) + " vs " + pairwise_chart["Target B"].astype(str)
+            pairwise_chart["Feature"] = pairwise_chart["Feature id"].astype(str)
         return (
             _cross_target_metrics_markdown(result),
             table,
             chart,
             summary_table,
+            pairwise_table,
+            pairwise_chart,
             _tsv(table),
             _tsv(summary_table),
+            _tsv(pairwise_table),
         )
     except Exception as exc:
         _raise_ui_error(exc)
@@ -1919,7 +1959,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.12</span></h1>'
+        '<h1>FeatureLens <span style="font-size:.48em;opacity:.58;font-weight:400">v0.13</span></h1>'
         '<div class="subtitle">Causal Interpretability Workbench</div>'
         '<div class="question">Discover sparse features, test robustness, and separate correlation from causal influence.</div>'
         '</header>'
@@ -2738,6 +2778,41 @@ with gr.Blocks(title="FeatureLens — Causal Interpretability Workbench", fill_w
         cross_target_summary_tsv = gr.Textbox(visible="hidden")
         cross_target_summary_copy = _copy_button()
 
+        gr.Markdown("#### Pairwise target preference shifts")
+        gr.Markdown(
+            "Derived from the same cross-target scores with **no additional model call**. For each feature, "
+            "Δ(A−B) = Δ mean log p/token(A) − Δ mean log p/token(B), so positive values mean the ablation shifts "
+            "token-normalized preference toward A relative to B."
+        )
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=3):
+                _table_heading('Pairwise target preference shifts')
+                cross_target_pairwise_table = gr.Dataframe(
+                    interactive=False,
+                    label="Pairwise target preference shifts",
+                    show_label=False,
+                    buttons=["fullscreen"],
+                    elem_classes=["result-table"],
+                    wrap=False,
+                    max_height=340,
+                )
+                cross_target_pairwise_tsv = gr.Textbox(visible="hidden")
+                cross_target_pairwise_copy = _copy_button()
+            with gr.Column(scale=2):
+                cross_target_pairwise_plot = gr.BarPlot(
+                    x="Target pair",
+                    y="Δ normalized preference A−B",
+                    color="Feature",
+                    title="Pairwise target preference shifts",
+                    elem_id="plot-cross-target-pairwise",
+                    x_title="Target pair",
+                    y_title="Δ normalized preference A−B",
+                    x_label_angle=-30,
+                    buttons=["fullscreen", "export"],
+                    elem_classes=["fl-plot"],
+                    height=330,
+                )
+
         gr.HTML('<div class="section-rule">D. Inspect one feature</div>')
         contrast_location = gr.Markdown(
             "**Activation trace uses the current Workbench prompt.** The controlled concept scan below uses its own balanced prompt set."
@@ -3225,8 +3300,11 @@ Association, robustness, geometry, and intervention evidence remain separate cla
             cross_target_table,
             cross_target_plot,
             cross_target_summary_table,
+            cross_target_pairwise_table,
+            cross_target_pairwise_plot,
             cross_target_tsv,
             cross_target_summary_tsv,
+            cross_target_pairwise_tsv,
         ],
     )
     candidate_specificity_table.select(
@@ -3295,6 +3373,7 @@ Association, robustness, geometry, and intervention evidence remain separate cla
         (controlled_alignment_copy, controlled_alignment_tsv),
         (cross_target_copy, cross_target_tsv),
         (cross_target_summary_copy, cross_target_summary_tsv),
+        (cross_target_pairwise_copy, cross_target_pairwise_tsv),
         (cue_copy, cue_tsv),
         (cue_context_copy, cue_context_tsv),
         (para_copy, para_tsv),

docs/METHODOLOGY.md

@@ -569,3 +569,17 @@ R_{profile} = \frac{\max_t |\Delta \bar{\ell}_t|}{\operatorname{mean}_{u \ne t^*
 \]
 
 This profile is a screening diagnostic and intentionally omits random controls. Random-normalized causal claims still require the Controlled candidate specificity experiment.
+
+## v0.13 resample stability and pairwise target preference
+
+### Deterministic balanced resampling
+
+The live discovery forward already yields a prompt-wide SAE activation vector for every controlled prompt. v0.13 reuses that tensor for 32 deterministic balanced bootstrap resamples. Each concept is resampled independently with replacement so the live concept balance is preserved. Candidate ranking is recomputed under the currently selected ranking mode, including the fixed current-token compatibility term for `causal_ready`. For every candidate in the full-data shortlist, FeatureLens records the fraction of resamples in which it reappears and its median rank when present. No model or SAE forward is repeated. Because the live prompt count is deliberately tiny, these are sensitivity descriptors rather than statistical confidence estimates.
+
+### Cross-target concentration
+
+For one feature with target effects `Δ_t`, v0.13 normalizes `|Δ_t|` into a probability vector and reports normalized entropy `H / log(T)`, effect concentration `1 − H/log(T)`, and signed bias `ΣΔ_t / Σ|Δ_t|`. These quantities distinguish target-concentrated effects from broad effects and indicate whether broad influence is primarily suppressive, enhancing, or mixed-sign. The profile text is a descriptive heuristic only.
+
+### Pairwise preference shifts
+
+For every unordered target pair `(A, B)`, FeatureLens derives `Δ_pref(A,B) = Δmean(A) − Δmean(B)` from the already-computed teacher-forced mean-log-probability effects. This is the intervention-induced change in token-normalized preference for A relative to B. It does not add a model call and does not replace matched-random specificity controls.

docs/VALIDATION.md

@@ -1,11 +1,9 @@
-# FeatureLens v0.12 validation
+# FeatureLens v0.13 validation
 
-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.
+v0.13 changes only **concept-guided discovery post-processing** and **cross-target profile post-processing**. Both changes reuse activations/scores already produced by those GPU calls. Do not rerun unrelated live experiments.
 
 ## Local release gate
 
-From the repository root:
-
 ```bash
 python3 -m pytest -q && \
 python3 -m compileall -q app.py featurelens experiments scripts && \
@@ -14,9 +12,7 @@ python3 scripts/ui_smoke.py && \
 python3 scripts/release_check.py
 ```
 
-Expected automated test count: **65 passed**.
-
-Expected release footer:
+Expected release checker tail:
 
 ```text
 FeatureLens release check: PASS
@@ -25,107 +21,69 @@ FeatureLens release check: PASS
   layers: [4, 14, 26]
   feature-set sizes: [1, 3, 5]
   random controls: 8
-  release: v0.12.0
+  release: v0.13.0
 ```
 
-## HF acceptance — only two GPU calls
-
-Use this Workbench context before both calls:
-
-```text
-Prompt: The derivative of x squared is
-Residual layer: 14
-Prompt token index: -1
-```
+## HF GPU call 1 — discovery stability
 
-You do not need to rerun single-feature causality, dose response, paraphrase robustness, layer trajectory, feature-set sweeps, cue diagnostics, or focus/zoom.
+Exact path: **Feature evidence → A. Concept-guided candidate discovery**.
 
-### GPU call 1 — touched discovery path
+Use:
 
-Exact UI path:
-
-**Feature evidence → A. Concept-guided candidate discovery**
-
-Set:
-
-```text
-Target concept: mathematics
-Residual layer: 14
-Prompts per concept: 4
-Candidate features: 12
-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`
+- Current Workbench prompt: `The derivative of x squared is`
+- Current Workbench token index: `-1`
 
-Click:
+Click **Discover concept-associated candidates**.
 
-**Discover concept-associated candidates**
+Record only the new stability evidence:
 
-Pass conditions:
+- split-half shared count and Jaccard;
+- summary mean resample support;
+- number of displayed candidates with ≥75% resample support;
+- for the top five rows: **Feature id**, **Resample shortlist support**, **Median resample rank**.
 
-- 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.
+No other discovery table columns need to be recopied unless the candidate ranking unexpectedly changes.
 
-Record only the split-half shared count/Jaccard unless the candidate ranking itself changes unexpectedly.
+## HF GPU call 2 — richer cross-target profile
 
-### GPU call 2 — new cross-target causal profile
+Exact path: **Feature evidence → C. Cross-target causal profile**.
 
-Exact UI path:
+Use:
 
-**Feature evidence → C. Cross-target causal profile**
-
-Set:
+- **Features for cross-target profile:** `25992`, `16369`, `21670`
+- **Exact target continuations:**
 
 ```text
-Features for cross-target profile:
-25992
-16369
-21670
-
-Exact target continuations (one per line):
 2x
 x
 0
 x^2
 ```
 
-Click:
-
-**Run cross-target causal profile**
-
-Pass conditions:
-
-- 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.
+Click **Run cross-target causal profile**.
 
-Please return:
+Send:
 
-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.
+1. **Target-profile summary** with the new columns **Normalized effect entropy**, **Effect concentration**, **Signed bias**, and **Profile pattern**.
+2. The top six rows of **Pairwise target preference shifts** by `|Preference shift|`.
+3. A screenshot of the pairwise plot if convenient.
 
-## Zero-GPU behavior covered by automated tests
+## Do not rerun for v0.13
 
-Do not spend HF quota solely to test these:
+Do **not** spend ZeroGPU quota on:
 
-- **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.
-
-## Do not rerun for v0.12
-
-Unless something visibly breaks, skip:
-
-- identity paraphrase;
+- controlled candidate specificity;
+- candidate triage;
+- dose response;
+- paraphrase identity;
 - layer trajectory;
 - 1/3/5 feature-set sweep;
-- scale dose-response;
-- cue × context;
-- controlled candidate specificity;
-- zoom/focus behavior.
+- cue or cue × context tests;
+- focus/zoom behavior.
 
-Those implementations are unchanged in v0.12 and remain covered by the automated suite.
+Those inference paths are unchanged in v0.13.

featurelens/runtime.py

@@ -5,6 +5,7 @@ import html
 import json
 import math
 import os
+import random
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass
@@ -244,6 +245,9 @@ class ConceptFeatureDiscoveryResult:
     split_half_k: int | None
     split_half_shared_count: int
     split_half_jaccard: float | None
+    resample_replicates: int
+    resample_mean_support: float | None
+    resample_high_support_count: int
 
 
 @dataclass
@@ -278,6 +282,7 @@ class CandidateCrossTargetResult:
     rows: list[list[object]]
     chart_rows: list[list[object]]
     summary_rows: list[list[object]]
+    pairwise_rows: list[list[object]]
     active_feature_count: int
 
 
@@ -1950,16 +1955,30 @@ 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.
+        # Stability diagnostics reuse the same controlled activation batch, so they add no model inference.
+        # Split-half overlap is intentionally simple; deterministic balanced bootstrap support gives a second
+        # view of how often each displayed feature survives small changes to the live prompt sample.
         split_half_k: int | None = None
         split_half_shared_count = 0
         split_half_jaccard: float | None = None
+        resample_replicates = 0
+        resample_rank_lists: list[list[int]] = []
+        row_concepts = [str(row['concept']) for row in rows]
 
-        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]
+        def _rank_indices(row_indices: list[int]) -> list[int]:
+            if not row_indices:
+                return []
+            index_tensor = torch.tensor(row_indices, device=dense.device, dtype=torch.long)
+            sub_dense = controlled_dense.index_select(0, index_tensor)
+            sub_labels = [row_concepts[index] for index in row_indices]
+            sub_target_mask = torch.tensor(
+                [label == concept for label in sub_labels],
+                device=dense.device,
+                dtype=torch.bool,
+            )
+            sub_other_mask = ~sub_target_mask
+            sub_target = sub_dense[sub_target_mask]
+            sub_other = sub_dense[sub_other_mask]
             if sub_target.shape[0] == 0 or sub_other.shape[0] == 0:
                 return []
             sub_target_mean = sub_target.mean(dim=0)
@@ -1989,18 +2008,17 @@ class FeatureLensRuntime:
         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'])
+            indices_a: list[int] = []
+            indices_b: list[int] = []
+            for row_idx, row_concept in enumerate(row_concepts):
                 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
+                    indices_a.append(row_idx)
                 else:
-                    mask_b[row_idx] = True
-            ids_a = _rank_subset(mask_a)
-            ids_b = _rank_subset(mask_b)
+                    indices_b.append(row_idx)
+            ids_a = _rank_indices(indices_a)
+            ids_b = _rank_indices(indices_b)
             if ids_a and ids_b:
                 set_a, set_b = set(ids_a), set(ids_b)
                 shared = set_a & set_b
@@ -2009,6 +2027,22 @@ class FeatureLensRuntime:
                 split_half_shared_count = len(shared)
                 split_half_jaccard = float(len(shared) / len(union)) if union else 1.0
 
+            pools: dict[str, list[int]] = {}
+            for row_idx, row_concept in enumerate(row_concepts):
+                pools.setdefault(row_concept, []).append(row_idx)
+            seed = 13013 + int(layer) * 97 + n * 17 + sum(ord(ch) for ch in concept)
+            rng = random.Random(seed)
+            resample_replicates = 32
+            for _ in range(resample_replicates):
+                sampled_indices: list[int] = []
+                for row_concept in sorted(pools):
+                    pool = pools[row_concept]
+                    sampled_indices.extend(rng.choice(pool) for _ in range(len(pool)))
+                ranked = _rank_indices(sampled_indices)
+                if ranked:
+                    resample_rank_lists.append(ranked)
+            resample_replicates = len(resample_rank_lists)
+
         eligible = (target_mean > 0) & (mean_diff > 0)
         if ranking_mode == 'causal_ready':
             if not current_context_available or resolved_current_idx is None:
@@ -2041,11 +2075,39 @@ class FeatureLensRuntime:
                 split_half_k=split_half_k,
                 split_half_shared_count=split_half_shared_count,
                 split_half_jaccard=split_half_jaccard,
+                resample_replicates=resample_replicates,
+                resample_mean_support=None,
+                resample_high_support_count=0,
             )
 
         order = torch.argsort(ranking_values[candidate_idx], descending=True)
         candidate_idx = candidate_idx[order[:top_n]]
 
+        resample_support: dict[int, float] = {}
+        resample_median_rank: dict[int, float | None] = {}
+        displayed_supports: list[float] = []
+        if resample_replicates:
+            for feature_tensor in candidate_idx:
+                fid = int(feature_tensor.item())
+                ranks = [ranked.index(fid) + 1 for ranked in resample_rank_lists if fid in ranked]
+                support = len(ranks) / resample_replicates
+                if ranks:
+                    ordered_ranks = sorted(ranks)
+                    midpoint = len(ordered_ranks) // 2
+                    if len(ordered_ranks) % 2:
+                        median_rank = float(ordered_ranks[midpoint])
+                    else:
+                        median_rank = float((ordered_ranks[midpoint - 1] + ordered_ranks[midpoint]) / 2)
+                else:
+                    median_rank = None
+                resample_support[fid] = float(support)
+                resample_median_rank[fid] = median_rank
+                displayed_supports.append(float(support))
+        resample_mean_support = (
+            float(sum(displayed_supports) / len(displayed_supports)) if displayed_supports else None
+        )
+        resample_high_support_count = sum(support >= 0.75 for support in displayed_supports)
+
         table_rows: list[list[object]] = []
         chart_rows: list[list[object]] = []
         default_candidate_id: int | None = None
@@ -2069,6 +2131,8 @@ class FeatureLensRuntime:
                 current_max,
                 current_token,
                 bool(current_token > 0),
+                resample_support.get(fid) if resample_replicates else None,
+                resample_median_rank.get(fid) if resample_replicates else None,
             ]
             table_rows.append(row)
             chart_rows.append([str(fid), score])
@@ -2088,10 +2152,13 @@ class FeatureLensRuntime:
             default_candidate_id=default_candidate_id,
             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),
+            displayed_current_active_count=sum(bool(row[11]) 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,
+            resample_replicates=resample_replicates,
+            resample_mean_support=resample_mean_support,
+            resample_high_support_count=resample_high_support_count,
         )
 
     @torch.inference_mode()
@@ -2527,6 +2594,7 @@ class FeatureLensRuntime:
                 by_feature[feature_id].append((target_text, mean_delta, js))
 
         summary_rows: list[list[object]] = []
+        pairwise_rows: list[list[object]] = []
         for feature_id in ids:
             items = by_feature[feature_id]
             strongest = max(items, key=lambda item: abs(item[1]))
@@ -2534,9 +2602,33 @@ class FeatureLensRuntime:
             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}
+            deltas = [float(item[1]) for item in items]
+            abs_values = [abs(delta) for delta in deltas]
+            total_abs = float(sum(abs_values))
+            if total_abs > 0 and len(abs_values) > 1:
+                proportions = [value / total_abs for value in abs_values if value > 0]
+                normalized_entropy = float(
+                    -sum(value * math.log(value) for value in proportions) / math.log(len(abs_values))
+                )
+            else:
+                normalized_entropy = 0.0
+            effect_concentration = float(1.0 - normalized_entropy)
+            signed_bias = float(sum(deltas) / total_abs) if total_abs > 0 else 0.0
+            signs = {1 if delta > 0 else -1 if delta < 0 else 0 for delta in deltas}
             nonzero_signs = {sign for sign in signs if sign != 0}
             sign_consistency = 'same sign' if len(nonzero_signs) <= 1 else 'mixed signs'
+            if effect_concentration >= 0.25:
+                profile_pattern = (
+                    'target-concentrated / mixed-sign'
+                    if sign_consistency == 'mixed signs'
+                    else 'target-concentrated / same-sign'
+                )
+            elif signed_bias <= -0.8:
+                profile_pattern = 'broad same-sign suppression'
+            elif signed_bias >= 0.8:
+                profile_pattern = 'broad same-sign enhancement'
+            else:
+                profile_pattern = 'broad mixed-sign'
             summary_rows.append(
                 [
                     int(feature_id),
@@ -2546,10 +2638,35 @@ class FeatureLensRuntime:
                     mean_other,
                     profile_ratio,
                     sign_consistency,
+                    normalized_entropy,
+                    effect_concentration,
+                    signed_bias,
+                    profile_pattern,
                     max(float(item[2]) for item in items),
                 ]
             )
+            for left_idx in range(len(items)):
+                for right_idx in range(left_idx + 1, len(items)):
+                    target_a, delta_a, _ = items[left_idx]
+                    target_b, delta_b, _ = items[right_idx]
+                    preference_shift = float(delta_a - delta_b)
+                    direction = (
+                        f'toward {target_a}'
+                        if preference_shift > 0
+                        else f'toward {target_b}' if preference_shift < 0 else 'no shift'
+                    )
+                    pairwise_rows.append(
+                        [
+                            int(feature_id),
+                            str(target_a),
+                            str(target_b),
+                            preference_shift,
+                            abs(preference_shift),
+                            direction,
+                        ]
+                    )
         summary_rows.sort(key=lambda row: float(row[3]), reverse=True)
+        pairwise_rows.sort(key=lambda row: float(row[4]), reverse=True)
 
         return CandidateCrossTargetResult(
             feature_ids=ids,
@@ -2557,6 +2674,7 @@ class FeatureLensRuntime:
             rows=rows,
             chart_rows=chart_rows,
             summary_rows=summary_rows,
+            pairwise_rows=pairwise_rows,
             active_feature_count=sum(activation > 0 for activation in activations),
         )
 

pyproject.toml

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

research_config.json

@@ -169,5 +169,13 @@
     "cross_target_candidate_profile",
     "missing_discovery_alignment_fallback",
     "gpu_budget_aware_touched_path_validation"
+  ],
+  "discovery_resample_replicates": 32,
+  "live_features_v0_13": [
+    "balanced_bootstrap_candidate_support",
+    "cross_target_effect_concentration",
+    "pairwise_target_preference_shifts",
+    "zero_extra_gpu_evidence_synthesis",
+    "touched_path_only_hf_validation"
   ]
 }

scripts/release_check.py

@@ -218,6 +218,21 @@ def check_config(config: dict) -> None:
         raise SystemExit(
             'research_config.json live_features_v0_12 mismatch: ' f'{sorted(actual_live_v12)}'
         )
+
+    required_live_v13 = {
+        'balanced_bootstrap_candidate_support',
+        'cross_target_effect_concentration',
+        'pairwise_target_preference_shifts',
+        'zero_extra_gpu_evidence_synthesis',
+        'touched_path_only_hf_validation',
+    }
+    actual_live_v13 = set(config.get('live_features_v0_13', []))
+    if actual_live_v13 != required_live_v13:
+        raise SystemExit(
+            'research_config.json live_features_v0_13 mismatch: ' f'{sorted(actual_live_v13)}'
+        )
+    if config.get('discovery_resample_replicates') != 32:
+        raise SystemExit('Discovery live resample count must be 32.')
     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.')
 
@@ -311,16 +326,20 @@ def check_readme() -> None:
         'split-half',
         'cross-target',
         'target-profile',
+        'resample shortlist support',
+        'pairwise target preference',
+        'effect concentration',
+        'signed bias',
     ]
     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.12 content: {missing}')
+        raise SystemExit(f'README.md is missing required v0.13 content: {missing}')
 
 
 def check_pyproject() -> None:
     text = (ROOT / 'pyproject.toml').read_text(encoding='utf-8')
-    if 'version = "0.12.0"' not in text:
-        raise SystemExit('pyproject.toml must declare version 0.12.0.')
+    if 'version = "0.13.0"' not in text:
+        raise SystemExit('pyproject.toml must declare version 0.13.0.')
 
 
 def main() -> None:
@@ -338,7 +357,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.12.0')
+    print('  release: v0.13.0')
 
 
 if __name__ == '__main__':

tests/test_live_runtime_helpers.py

@@ -233,7 +233,7 @@ def test_concept_feature_discovery_runs_on_toy_runtime() -> None:
     assert result.current_token_index == 2
     assert len(result.rows) <= 3
     assert result.candidate_ids == [int(row[1]) for row in result.rows]
-    assert all(len(row) == 12 for row in result.rows)
+    assert all(len(row) == 14 for row in result.rows)
     if result.rows:
         assert result.default_candidate_id in result.candidate_ids
         assert all(math.isfinite(float(row[2])) for row in result.rows)
@@ -253,7 +253,7 @@ def test_concept_feature_discovery_supports_raw_mean_difference() -> None:
     assert result.ranking_mode == 'raw_mean_difference'
     assert result.current_context_available is False
     assert result.current_token_index is None
-    assert all(len(row) == 12 for row in result.rows)
+    assert all(len(row) == 14 for row in result.rows)
 
 
 
@@ -272,7 +272,7 @@ def test_concept_feature_discovery_supports_causal_ready_mode() -> None:
     assert result.ranking_mode == 'causal_ready'
     assert result.current_context_available is True
     assert result.displayed_current_active_count == len(result.rows)
-    assert all(bool(row[-1]) for row in result.rows)
+    assert all(bool(row[11]) for row in result.rows)
 
 
 def test_concept_feature_discovery_causal_ready_requires_workbench_context() -> None:
@@ -382,6 +382,29 @@ def test_concept_feature_discovery_reports_split_half_stability_without_extra_fo
         assert 0 <= result.split_half_shared_count <= max(len(result.candidate_ids), result.split_half_k)
 
 
+def test_concept_feature_discovery_reports_resample_support_from_same_batch() -> 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,
+    )
+    assert 0 <= result.resample_replicates <= 32
+    if result.resample_replicates and result.rows:
+        assert result.resample_mean_support is not None
+        assert 0.0 <= result.resample_mean_support <= 1.0
+        assert 0 <= result.resample_high_support_count <= len(result.rows)
+        for row in result.rows:
+            assert row[12] is not None
+            assert 0.0 <= float(row[12]) <= 1.0
+            if row[13] is not None:
+                assert 1.0 <= float(row[13]) <= result.top_n
+
+
 def test_candidate_cross_target_profile_runs_multiple_features_and_targets() -> None:
     runtime = make_runtime()
     result = runtime.candidate_cross_target_profile(
@@ -397,5 +420,11 @@ def test_candidate_cross_target_profile_runs_multiple_features_and_targets() ->
     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(len(row) == 12 for row in result.summary_rows)
+    assert len(result.pairwise_rows) == 2 * 3  # 2 features × C(3 targets, 2)
+    assert all(len(row) == 6 for row in result.pairwise_rows)
+    assert all(0.0 <= float(row[7]) <= 1.0 for row in result.summary_rows)  # normalized entropy
+    assert all(0.0 <= float(row[8]) <= 1.0 for row in result.summary_rows)  # concentration
+    assert all(-1.0 <= float(row[9]) <= 1.0 for row in result.summary_rows)  # signed bias
+    assert all(isinstance(row[10], str) and row[10] for row in result.summary_rows)
     assert all(math.isfinite(float(row[5])) for row in result.rows)

tests/test_ui_helpers.py

@@ -308,3 +308,58 @@ def test_cross_target_ui_has_independent_targets_and_small_feature_limit() -> No
     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
+
+
+def test_v13_discovery_markdown_reports_resample_support() -> None:
+    app = _import_app()
+    result = SimpleNamespace(
+        candidate_ids=[16369, 5712, 26112],
+        concept='mathematics',
+        layer=14,
+        prompts_per_concept=4,
+        ranking_mode='causal_ready',
+        current_context_available=True,
+        current_token_index=5,
+        displayed_current_active_count=3,
+        split_half_k=3,
+        split_half_shared_count=2,
+        split_half_jaccard=0.5,
+        resample_replicates=32,
+        resample_mean_support=0.71875,
+        resample_high_support_count=2,
+    )
+    text = app._discovery_metrics_markdown(result)
+    assert '32 resamples' in text
+    assert '71.9%' in text
+    assert '2/3' in text
+    assert 'confidence interval' in text
+
+
+def test_v13_cross_target_markdown_reports_profile_and_pairwise_summary() -> None:
+    app = _import_app()
+    result = SimpleNamespace(
+        feature_ids=[25992, 16369],
+        targets=['2x', 'x', '0', 'x^2'],
+        active_feature_count=2,
+        summary_rows=[
+            [16369, 'x', 0.2883, 0.2883, 0.0513, 5.62, 'mixed signs', 0.58, 0.42, 0.92,
+             'target-concentrated / mixed-sign', 0.0017],
+            [25992, '0', -0.1657, 0.1657, 0.0936, 1.77, 'same sign', 0.95, 0.05, -1.0,
+             'broad same-sign suppression', 0.0011],
+        ],
+        pairwise_rows=[
+            [16369, 'x', '0', 0.2969, 0.2969, 'toward x'],
+        ],
+    )
+    text = app._cross_target_metrics_markdown(result)
+    assert 'target-concentrated / mixed-sign' in text
+    assert 'broad same-sign suppression' in text
+    assert 'pairwise preference shift' in text
+    assert "'x' vs '0'" in text
+
+
+def test_v13_pairwise_cross_target_ui_is_zero_extra_gpu_output() -> None:
+    app = _import_app()
+    assert app.cross_target_pairwise_table.show_label is False
+    assert app.cross_target_pairwise_plot.title == 'Pairwise target preference shifts'
+    assert app.cross_target_pairwise_plot.visible is True