Backend: ephemeral flag on analyze stream — leave no cache trace

The What-if Rewrite & rerun re-uses /analyze/research/attention/stream
to regenerate text with an edited prompt. That endpoint
unconditionally called matrix_cache.clear_old_requests(new_id) on
every invocation, evicting the original traced run's matrices and
hidden states — so opening the Mechanism / Attention lenses
afterwards surfaced "Matrix data not found. Cache may have
expired."

Adds an opt-in ephemeral=true field on the stream request body.
When true, the handler skips every cache touch:
- clear_old_requests (keep prior runs intact)
- set_request_metadata
- set_step_query_info
- hidden_state_cache.store_step / store_input_ids
- matrix_cache.store (per-layer, per-head)

Default behaviour (no flag) is byte-identical to before, so every
existing caller — the main "Generate trace" path, the non-streaming
sibling, every other endpoint — is untouched. Only the What-if
regen opts in.

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

backend/model_service.py

@@ -2914,13 +2914,27 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
             # Generate unique request ID for matrix cache lookup
             request_id = str(uuid.uuid4())
 
+            # `ephemeral` callers (e.g. the What-if "Rewrite & rerun"
+            # counterfactual) want their regen to coexist with the
+            # original traced run rather than displace it — the user
+            # still needs the original's matrices for the Mechanism /
+            # Attention lenses. The new request_id is unique, so the
+            # ephemeral run's own writes don't collide; we just have to
+            # skip the eager `clear_old_requests` that would otherwise
+            # purge every other request_id's cache.
+            ephemeral = bool(request.get("ephemeral", False))
+
             # Clear old cached matrices to free memory before starting new analysis
-            matrix_cache.clear_old_requests(request_id)
+            if not ephemeral:
+                matrix_cache.clear_old_requests(request_id)
 
             # Record per-request model metadata so aggregate-row lookups can
             # derive num_heads from this request rather than from the live
             # `manager.model` (which may have been switched in the meantime).
-            if manager.adapter is not None:
+            # Ephemeral runs (What-if Rewrite & rerun) skip every cache
+            # write — the frontend discards everything except the
+            # generated tokens, so the regen leaves no trace at all.
+            if manager.adapter is not None and not ephemeral:
                 matrix_cache.set_request_metadata(
                     request_id,
                     num_heads=manager.adapter.get_num_heads(),
@@ -3305,9 +3319,10 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                     # step's token (see non-SSE site for rationale).
                     query_position = current_ids.shape[1] - 1
                     query_token_id = current_ids[0, -1].item()
-                    matrix_cache.set_step_query_info(
-                        request_id, step, query_position, query_token_id
-                    )
+                    if not ephemeral:
+                        matrix_cache.set_step_query_info(
+                            request_id, step, query_position, query_token_id
+                        )
 
                     # Get logits for next token
                     raw_logits = outputs.logits[0, -1, :].clone()  # Clone raw logits before any scaling
@@ -3594,12 +3609,13 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                     })
 
                     # Cache hidden states, logits, and full sequence for intervention endpoint
-                    try:
-                        hidden_state_cache.store_step(request_id, step, outputs.hidden_states, raw_logits, current_ids)
-                        if step == 0:
-                            hidden_state_cache.store_input_ids(request_id, current_ids[:, :-1])  # prompt only
-                    except Exception as hs_err:
-                        logger.debug(f"Hidden state cache error at step {step}: {hs_err}")
+                    if not ephemeral:
+                        try:
+                            hidden_state_cache.store_step(request_id, step, outputs.hidden_states, raw_logits, current_ids)
+                            if step == 0:
+                                hidden_state_cache.store_input_ids(request_id, current_ids[:, :-1])  # prompt only
+                        except Exception as hs_err:
+                            logger.debug(f"Hidden state cache error at step {step}: {hs_err}")
 
                     # Emit generated token immediately so clients can show code progressively
                     yield sse_event('generated_token', stage=2, totalStages=5,
@@ -3866,12 +3882,13 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                                 k_matrix = qkv_layer['k'][:, head_idx, :].float().numpy()
                                 v_matrix = qkv_layer['v'][:, head_idx, :].float().numpy()
 
-                            matrix_cache.store(request_id, step, layer_idx, head_idx, {
-                                "attention_weights": attention_matrix,
-                                "q_matrix": q_matrix,
-                                "k_matrix": k_matrix,
-                                "v_matrix": v_matrix
-                            })
+                            if not ephemeral:
+                                matrix_cache.store(request_id, step, layer_idx, head_idx, {
+                                    "attention_weights": attention_matrix,
+                                    "q_matrix": q_matrix,
+                                    "k_matrix": k_matrix,
+                                    "v_matrix": v_matrix
+                                })
 
                             head_entry = {
                                 "head_idx": head_idx,