Backend: add mask_positions intervention for What-if "Test this token"

The frontend's What-if lens "Test this token" mode posts
intervention_type=mask_positions with a list of arbitrary prompt
positions to mask, but the backend only ever implemented the three
contiguous-region masks (mask_system / mask_user_span /
mask_generated). Requests hit the "Unknown intervention type"
fallthrough.

Adds a mask_positions branch to /analyze/intervention:
- params.positions: list[int] (clamped to valid range, deduped)
- params.selected_token_id: int (optional; defaults to original
step's winner — the token whose logit delta we track)
- params.top_k: int (default 8, clamped 1–50)

Zeroes those positions in the attention mask, re-runs the forward
pass, returns the standard InterventionResponse with a rich details
dict matching the frontend's AblationResult interface: mask_type,
mask_positions_count, ablated_positions, seq_len, prompt_len,
selected_token_id / selected_token, selected_logit_original /
_ablated / _delta, and top_k_after_ablation with per-entry
{token_id, token, logit, probability}.

Verified locally: marking "implementation of" in a quicksort
prompt shifts the score by -0.375 and surfaces the top-6
post-ablation alternatives correctly.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

backend/model_service.py

@@ -4503,7 +4503,7 @@ async def get_attention_row(
 class InterventionRequest(BaseModel):
     request_id: str
     step: int
-    intervention_type: str  # "mask_system" | "mask_user_span" | "mask_generated" | "greedy" | "temperature_sweep" | "layer_ablation" | "head_ablation" | "expert_mask"
+    intervention_type: str  # "mask_system" | "mask_user_span" | "mask_generated" | "mask_positions" | "greedy" | "temperature_sweep" | "layer_ablation" | "head_ablation" | "expert_mask"
     params: dict = {}
 
 class InterventionResponse(BaseModel):
@@ -4661,6 +4661,113 @@ async def run_intervention(request: InterventionRequest, authenticated: bool = D
                 }
             )
 
+        elif request.intervention_type == "mask_positions":
+            # Per-position mask: the caller hands us an explicit list of
+            # absolute token positions to zero out in the attention mask.
+            # Used by the What-if lens's "Test this token" mode where the
+            # user marks individual prompt tokens (not contiguous spans).
+            #
+            # Returns a richer details dict than the contiguous-region
+            # mask handlers: top-K alternatives post-ablation, plus the
+            # selected token's logit delta if the caller passed
+            # selected_token_id. The frontend's AblationResult interface
+            # expects all of these.
+            positions = request.params.get("positions", []) or []
+            if not isinstance(positions, list) or not all(isinstance(p, int) for p in positions):
+                raise HTTPException(status_code=400, detail="mask_positions requires params.positions: list[int]")
+            top_k = int(request.params.get("top_k", 8))
+            top_k = max(1, min(top_k, 50))
+            selected_token_id_param = request.params.get("selected_token_id")
+
+            cached_current_ids = hidden_state_cache.get_current_ids(request.request_id, request.step)
+            input_ids_prompt = hidden_state_cache.get_input_ids(request.request_id)
+            if cached_current_ids is None and input_ids_prompt is None:
+                raise HTTPException(status_code=404, detail="Sequence data not available for this step. Please re-generate.")
+
+            if cached_current_ids is not None:
+                full_ids = cached_current_ids.to(manager.device)
+            else:
+                full_ids = input_ids_prompt.to(manager.device)
+
+            seq_len = full_ids.shape[-1]
+            prompt_len = input_ids_prompt.shape[-1] if input_ids_prompt is not None else seq_len
+
+            # Clamp to valid range and dedupe. Out-of-range positions are
+            # silently dropped rather than raising — the UI may send a
+            # stale set if the user navigated between steps with marks
+            # still active.
+            valid_positions = sorted({p for p in positions if 0 <= p < seq_len})
+
+            attention_mask = torch.ones(1, seq_len, dtype=torch.long, device=manager.device)
+            for p in valid_positions:
+                attention_mask[0, p] = 0
+
+            with torch.no_grad():
+                masked_outputs = manager.model(
+                    full_ids,
+                    attention_mask=attention_mask,
+                    output_hidden_states=False,
+                    output_attentions=False,
+                )
+                recomputed_logits = masked_outputs.logits[0, -1, :]
+
+            top2_new, top2_new_ids = torch.topk(recomputed_logits, k=2)
+            top2_new_list = top2_new.cpu().tolist()
+            top2_new_ids_list = top2_new_ids.cpu().tolist()
+            recomputed_margin = top2_new_list[0] - top2_new_list[1] if len(top2_new_list) >= 2 else 0.0
+            recomputed_winner = manager.tokenizer.decode([top2_new_ids_list[0]], skip_special_tokens=False)
+
+            # The "selected token" is the one the user is studying — by
+            # default the original winner at this step, but the caller
+            # can override (e.g. to track the runner-up's behaviour).
+            if isinstance(selected_token_id_param, int):
+                selected_token_id = selected_token_id_param
+            else:
+                selected_token_id = top2_orig_ids_list[0]
+            selected_token_text = manager.tokenizer.decode([selected_token_id], skip_special_tokens=False)
+            selected_logit_original = float(raw_logits[selected_token_id].item())
+            selected_logit_ablated = float(recomputed_logits[selected_token_id].item())
+            selected_logit_delta = selected_logit_ablated - selected_logit_original
+
+            # Top-K alternatives after ablation, with both logits and
+            # softmax probabilities so the frontend can render either.
+            recomputed_probs = torch.softmax(recomputed_logits, dim=0)
+            topk_vals, topk_ids = torch.topk(recomputed_logits, k=top_k)
+            topk_ids_list = topk_ids.cpu().tolist()
+            topk_vals_list = topk_vals.cpu().tolist()
+            top_k_after_ablation = []
+            for tid, logit_val in zip(topk_ids_list, topk_vals_list):
+                top_k_after_ablation.append({
+                    "token_id": int(tid),
+                    "token": manager.tokenizer.decode([tid], skip_special_tokens=False),
+                    "logit": float(logit_val),
+                    "probability": float(recomputed_probs[tid].item()),
+                })
+
+            return InterventionResponse(
+                original_margin=original_margin,
+                recomputed_margin=recomputed_margin,
+                margin_shift=recomputed_margin - original_margin,
+                original_stability=_classify_stability(original_margin),
+                recomputed_stability=_classify_stability(recomputed_margin),
+                original_winner=original_winner,
+                recomputed_winner=recomputed_winner,
+                winner_changed=top2_new_ids_list[0] != top2_orig_ids_list[0],
+                details={
+                    "mask_type": "mask_positions",
+                    "mask_positions_count": len(valid_positions),
+                    "ablated_positions": valid_positions,
+                    "seq_len": seq_len,
+                    "prompt_len": prompt_len,
+                    "selected_token_id": int(selected_token_id),
+                    "selected_token": selected_token_text,
+                    "selected_logit_original": selected_logit_original,
+                    "selected_logit_ablated": selected_logit_ablated,
+                    "selected_logit_delta": selected_logit_delta,
+                    "top_k_after_ablation": top_k_after_ablation,
+                }
+            )
+
         elif request.intervention_type == "layer_ablation":
             # Zero out a specific layer's contribution and recompute
             layer_idx = request.params.get("layer_idx", 0)