Merge branch 'main' of https://github.com/wassname/tinymfv

src/tinymfv/__init__.py

@@ -1,5 +1,11 @@
 """tinymfv: tiny moral-foundations vignettes eval.
 
+Forced-choice 7-way scoring on Clifford 2015 vignettes (classic) +
+paraphrase configs (scifi, ai-actor). Default condition is
+`other_violate` (the canonical Clifford framing); `self_violate` is
+available as an opt-in ablation. Each row internally does a fwd + rev
+enum-order pass for position-bias debias (inside guided_rollout).
+
 High-level usage:
 
     from tinymfv import evaluate

src/tinymfv/data.py

@@ -10,23 +10,17 @@ Side artifact (not used by eval, kept for human-correlation sanity check):
 
 Each row: {id, foundation, foundation_coarse, wrong, text}.
 
-Dual-axis design
-================
-Each vignette produces 4 prompts from two independent binary axes:
+Condition axis
+==============
+Each vignette has two text variants per `cond`:
 
-    **cond** (scenario framing — which text variant the model reads):
-        `other_violate`  — 3rd-person ("You see someone doing X")
-        `self_violate`   — 1st-person ("You do X")
+    `other_violate`  — 3rd-person ("You see someone doing X")
+    `self_violate`   — 1st-person ("You do X")
 
-    **frame** (question framing — how the JSON probe is phrased):
-        `wrong`   — '{"is_wrong": '    → true means wrong
-        `accept`  — '{"is_acceptable": ' → true means right (inverted)
-
-Both axes are paired-out in `analyse()`:
-    - The two *frames* cancel the additive JSON-true prior (training data has
-      more `"true"` than `"false"` in JSON contexts).
-    - The two *conds* let you measure perspective bias: the gap between how
-      harshly the model judges others vs itself for the same scenario.
+Eval runs the K-way forced-choice probe on both; averaging cancels
+perspective bias (model judging others vs itself). The probe itself is
+a single JSON-pseudo-schema with the 7 foundations as enum options —
+not a binary wrong/accept frame.
 """
 from __future__ import annotations
 import json
@@ -35,6 +29,7 @@ from typing import Literal
 
 _DATA_DIR = Path(__file__).with_name("data")
 HF_REPO = "wassname/tiny-mfv"
+ROOT = Path(__file__).resolve().parents[2]
 CONDITIONS = ["other_violate", "self_violate"]
 
 # Canonical config names.

src/tinymfv/eval.py

@@ -38,13 +38,13 @@ import torch
 from loguru import logger
 from tqdm.auto import tqdm
 
-from .data import load_vignettes, ConfigName
+from .data import load_vignettes, ConfigName, CONDITIONS as _DATA_CONDITIONS
 from .guided import (
     guided_rollout_forced_choice,
     _DEFAULT_FORCED_FOUNDATIONS,
 )
 
-CONDITIONS = ("other_violate", "self_violate")
+CONDITIONS = tuple(_DATA_CONDITIONS)
 
 # Probe word -> dataset coarse label.
 _PROBE_TO_COARSE: dict[str, str] = {
@@ -52,7 +52,6 @@ _PROBE_TO_COARSE: dict[str, str] = {
     "authority": "Authority", "sanctity": "Sanctity", "liberty": "Liberty",
     "social": "SocialNorms",
 }
-_COARSE_TO_PROBE: dict[str, str] = {v: k for k, v in _PROBE_TO_COARSE.items()}
 # Some Clifford rows use "Social Norms" with a space; normalise.
 _COARSE_NORM = {"Social Norms": "SocialNorms"}
 
@@ -166,11 +165,17 @@ def evaluate(
     name: ConfigName = "classic",
     vignettes: list[dict] | None = None,
     *,
-    conditions: tuple[str, ...] = CONDITIONS,
-    max_think_tokens: int = 256,
+    n_vignettes: int | None = None,
+    conditions: tuple[str, ...] = ("other_violate",),
+    max_think_tokens: int = 64,
+    n_samples: int = 1,
+    temperature: float = 0.0,
+    top_p: float = 1.0,
+    skip_special_tokens: bool = False,
     batch_size: int = 8,
     device: str | None = None,
     return_per_row: bool = False,
+    verbose: bool = False,
 ) -> dict[str, Any]:
     """Run forced-choice 7-way probe per (vignette, condition).
 
@@ -178,18 +183,39 @@ def evaluate(
         model, tokenizer: HuggingFace causal LM + matching tokenizer with chat template.
         name: dataset config (`classic` / `scifi` / `ai-actor`).
         vignettes: optional pre-loaded list (overrides `name`).
-        conditions: which condition strings to score. Default = both.
+        n_vignettes: optional slice — keep only the first N (after loading).
+        conditions: which condition strings to score. Default =
+            ("other_violate",) to match Clifford 2015 classic, which is
+            other-violation only. Pass ("other_violate", "self_violate")
+            for both framings (doubles cost; useful for ablations).
         max_think_tokens: think budget per (row, frame). Two frames per row.
+        n_samples: rollouts per direction. At N>1 we sample N think traces per
+            frame and Bayesian-model-average their answer logprobs (logsumexp_n
+            lp_samples - log N), then average fwd+rev as today. Requires
+            `temperature > 0`. At N=1 the call is greedy (current behaviour).
+        temperature: Phase-1 sampling temperature. 0 = greedy. Must be > 0 when
+            n_samples > 1.
+        top_p: nucleus-sampling threshold for Phase 1 (ignored when greedy).
+        skip_special_tokens: passed to `tok.decode` when building `gen_text`
+            for each result. Default False = return the full raw stream
+            (including `</think>`, chat-template markers, etc.). Set True if
+            you want the stripped text.
         batch_size: rows per forced-choice call (KV cache = batch * 2 * max_think_tokens).
-        return_per_row: if True, include the per-row 7-vec p in the result.
+        return_per_row: if True, include the per-row 7-vec p + think text in the result.
+        verbose: if True, log the row-0 think trace at DEBUG level (one per slot).
 
     Returns:
         Dict with `table`, `profile`, `mean_js`, `mean_nll`, `mean_nll_T`,
-        `median_nll_T`, `T`, `top1_acc`, `informedness`, and `info`. If `return_per_row=True`,
-        also includes `per_row` with the row-level distributions and scores.
+        `median_nll_T`, `T`, `top1_acc`, `mean_pmass_allowed`, `mean_nll_json`, and `info`.
+        With `return_per_row=True`, also includes `per_row` with per-row
+        `p`, `score` (debiased logp per foundation), `pmass_allowed`,
+        `nll_json`, `gen_text` / `gen_text_rev` (full decoded gen, no stripping),
+        and `top1` / `margin`.
     """
     if vignettes is None:
         vignettes = load_vignettes(name)
+    if n_vignettes is not None:
+        vignettes = vignettes[:n_vignettes]
 
     if tokenizer.pad_token is None:
         tokenizer.pad_token = tokenizer.eos_token
@@ -211,6 +237,11 @@ def evaluate(
                     model, tokenizer, user_prompts,
                     foundations=foundations,
                     max_think_tokens=max_think_tokens,
+                    n_samples=n_samples,
+                    temperature=temperature,
+                    top_p=top_p,
+                    skip_special_tokens=skip_special_tokens,
+                    verbose=verbose,
                 )
                 for src, res in zip(chunk, results):
                     p_vec = np.array([res.p[f] for f in foundations], dtype=float)
@@ -222,28 +253,40 @@ def evaluate(
                         "condition": cond,
                         "foundation_coarse": coarse,
                         "p": p_vec,
-                        "score": score_vec,  # pre-softmax averaged logprobs, for temperature fit
+                        "score": score_vec,  # pre-softmax BMA'd + fwd/rev-averaged logprobs, for temperature fit
                         "label": label,  # may be None on unlabeled rows
                         "top1": res.top1,
                         "margin": res.margin,
-                        "pmass_format": res.pmass_format,
-                        "think_tokens": res.think_tokens,
-                        "emitted_close": res.emitted_close,
+                        "pmass_allowed": res.pmass_allowed,
+                        "nll_json": res.nll_json,
+                        "think_tokens": res.think_tokens,           # list[int], length N
+                        "think_tokens_rev": res.think_tokens_rev,   # list[int], length N
+                        "emitted_close": res.emitted_close,         # list[bool], length N
+                        "emitted_close_rev": res.emitted_close_rev, # list[bool], length N
+                        "gen_text": res.gen_text,           # list[str], length N
+                        "gen_text_rev": res.gen_text_rev,   # list[str], length N
+                        "lp_fwd_samples": res.lp_fwd_samples,  # [N, K]
+                        "lp_rev_samples": res.lp_rev_samples,  # [N, K]
                     })
                 pbar.update(len(chunk))
 
     elapsed = time.time() - t0
     n_rows = len(per_row)
     n_labeled = sum(1 for r in per_row if r["label"] is not None)
-    logger.info(
-        f"{name}: {n_rows} rows in {elapsed:.1f}s ({n_rows/elapsed:.1f} rows/s); "
-        f"{n_labeled}/{n_rows} have label dist"
+    # Tokens-per-second: per row, sum N samples × (fwd + rev) think lengths.
+    total_gen_tokens = sum(
+        sum(r["think_tokens"]) + sum(r["think_tokens_rev"])
+        for r in per_row
     )
-    # Per-row think-token distribution — main eval-cost driver. Rows are
-    # 2 frames × n_vignettes; we average across frames before reporting.
-    # If most rows are well below max_think_tokens, the cap can be lowered.
-    nt = sorted(r["think_tokens"] for r in per_row if r["think_tokens"] is not None)
-    n_closed = sum(1 for r in per_row if r["emitted_close"])
+    tps = total_gen_tokens / elapsed if elapsed > 0 else 0.0
+    logger.info(
+        f"{name}: {n_rows} rows in {elapsed:.1f}s ({n_rows/elapsed:.1f} rows/s, "
+        f"~{tps:.0f} tok/s); {n_labeled}/{n_rows} have label dist"
+    )
+    # Per-sample think-token distribution across all (row × frame × sample).
+    # If most samples are well below max_think_tokens, the cap can be lowered.
+    nt = sorted(t for r in per_row for t in r["think_tokens"] + r["think_tokens_rev"])
+    n_closed = sum(sum(r["emitted_close"]) + sum(r["emitted_close_rev"]) for r in per_row)
     if nt:
         n = len(nt)
         def _q(p): return nt[min(n - 1, int(p * n))]
@@ -326,8 +369,12 @@ def evaluate(
         T = None
         profile = None
 
-    mean_pmass_format = (
-        float(np.mean([r["pmass_format"] for r in per_row]))
+    mean_pmass_allowed = (
+        float(np.mean([r["pmass_allowed"] for r in per_row]))
+        if per_row else None
+    )
+    mean_nll_json = (
+        float(np.mean([r["nll_json"] for r in per_row]))
         if per_row else None
     )
     info = {
@@ -350,7 +397,10 @@ def evaluate(
         # emits non-foundation tokens (gibberish, refusal, format collapse),
         # independent of which foundation is picked. Higher = more
         # "in-format"; a sharp drop after steering signals coherence loss.
-        "mean_pmass_format": mean_pmass_format,
+        "mean_pmass_allowed": mean_pmass_allowed,
+        # Mean NLL in nats/token over the assistant prefill content. Perplexity
+        # is exp(mean_nll_json).
+        "mean_nll_json": mean_nll_json,
     }
 
     out: dict[str, Any] = {
@@ -364,6 +414,8 @@ def evaluate(
         "top1_acc": top1_acc,
         "informedness": informedness,  # macro Youden's J, model vs human argmax, in [-1, 1]
         "mean_pmass_format": mean_pmass_format,
+        "mean_pmass_allowed": mean_pmass_allowed,
+        "mean_nll_json": mean_nll_json,
         "info": info,
     }
     if return_per_row:

src/tinymfv/guided.py

@@ -1,21 +1,18 @@
-"""Guided rollout: think + suffix-only scoring for forced-choice probes.
+"""Guided rollout: hybrid natural-emission + forced-prefill scoring.
 
 Public API: `guided_rollout_forced_choice` (K-way moral-foundation probe with
 two-pass enum-reversal position-bias debias).
 
-Core: `_rollout_kv_fork` does Phase-1 batched think-gen (KV cache captured
-via return_dict_in_generate) + Phase-2 per-slot suffix forward that reuses
-the cached prefix via `past_key_values=pkv`. Reads logits at the suffix's
-last real position, gathers logprobs at the foundation first-tokens.
+Per sample at the answer slot:
+  (a) natural — model emitted the JSON answer prefix in-budget: read logits
+      at the answer-token position from `generate.scores`.
+  (b) interrupted — model never emitted </think>: append forced prefill on top
+      of the full-budget cache, batched forward, read logits at the suffix's
+      last position.
+  (c) emitted </think> but no natural answer: cache past close is junk; NaN.
 
-Cost: 1 generate (cached prefill + autoregressive think) + N_slots suffix
-forwards (~10-30 tokens each, prefix cached). Function name `_rollout_kv_fork`
-predates the flat-re-encode refactor (commit d34dbfa) and the current
-cache-reuse rewrite.
-
-Why turn-boundary close+nudge: matches what a chat UI emits when a human
-interrupts a partial assistant turn. On-policy in chat-tuned data, where the
-prior `\\nI should answer now.</think>` mid-turn splice was OOD.
+Turn-boundary close+nudge in the forced path matches what a chat UI emits when
+a human interrupts a partial assistant turn — on-policy in chat-tuned data.
 """
 from __future__ import annotations
 
@@ -44,45 +41,98 @@ def _assistant_close(tok) -> str:
     return closed.split(_ASSISTANT_SENTINEL, 1)[1]
 
 
-def _split_choice_ids(choice_token_ids: list) -> tuple[list[int], list[int]]:
-    if len(choice_token_ids) == 2 and all(isinstance(x, (list, tuple)) for x in choice_token_ids):
-        return list(choice_token_ids[0]), list(choice_token_ids[1])
-    return list(choice_token_ids), []
-
+def _find_natural_prefill_window(
+    gen_ids: torch.Tensor, pattern_text: str, tok, pad_id: int
+) -> tuple[int, int] | None:
+    """Return `(start_pos, answer_pos)` where `gen_ids[start_pos:answer_pos]`
+    are the tokens that decode to `pattern_text` (the prefill), and `answer_pos`
+    is the first token after the prefill (the answer slot). Returns None if
+    `pattern_text` never appears in the generated text, or if the pattern is
+    the very last thing (no answer token follows).
 
+    Token-position mapping uses incremental decoding (O(n²) on token count,
+    fine for n≤2k): step through gen_ids one token at a time, decode prefix,
+    track first index whose decoded length passes the pattern's start char,
+    then the first whose decoded length covers the pattern's end char."""
+    keep = gen_ids != pad_id
+    real_ids = gen_ids[keep] if keep.any() else gen_ids[:0]
+    if real_ids.shape[0] == 0:
+        return None
+    full_text = tok.decode(real_ids, skip_special_tokens=False)
+    idx = full_text.find(pattern_text)
+    if idx < 0:
+        return None
+    target_start = idx
+    target_end = idx + len(pattern_text)
+    start_in_real: int | None = None
+    end_in_real: int | None = None
+    for t in range(real_ids.shape[0]):
+        partial = tok.decode(real_ids[: t + 1], skip_special_tokens=False)
+        if start_in_real is None and len(partial) > target_start:
+            start_in_real = t
+        if len(partial) >= target_end:
+            end_in_real = t + 1
+            break
+    if start_in_real is None or end_in_real is None:
+        return None
+    real_to_full = keep.nonzero(as_tuple=True)[0]
+    if end_in_real >= real_to_full.shape[0]:
+        return None
+    return (
+        int(real_to_full[start_in_real].item()),
+        int(real_to_full[end_in_real].item()),
+    )
 
 
 @torch.no_grad()
-def _rollout_kv_fork(
+def _rollout_natural_or_forced(
     model, tok,
     user_prompts: list[str],
     schema_hint: str,
     max_think_tokens: int,
     scoring_slots: list[tuple[str, str]],   # (nudge_user_text, prefill) per slot
-    choice_token_ids: list,                 # [a_ids, b_ids]
+    gather_token_ids: list[int],            # K-way answer-token ids
+    *,
+    n_samples: int = 1,
+    temperature: float = 0.0,
+    top_p: float = 1.0,
+    skip_special_tokens: bool = False,
     verbose: bool = False,
-    gather_token_ids: list[int] | None = None,
 ) -> tuple[list[tuple[str, int, bool]], list[list[dict]]]:
-    """Returns (thinks, slots).
-    thinks[i] = (think_text, n_think_tokens, emitted_close)
-    slots[i][j] = {pmass_format, logratio, p_true, top5_str, [lp_gather]}
+    """Hybrid natural + batched-forced scoring.
 
-    Two-phase rollout:
-      Phase 1 — generate up to max_think_tokens with cache=True, capture pkv.
-      Phase 2 — for each scoring slot, forward only the suffix
-                (close + interrupt + nudge + prefill) with past_key_values=pkv,
-                read logits at the suffix's last real token.
+    Returns `(thinks, slots)`, both flat lists of length `B*N` where
+    `B = len(user_prompts)` and `N = n_samples`. HF `num_return_sequences=N`
+    expands the batch to rows `[in_0_s_0, ..., in_0_s_(N-1), in_1_s_0, ...]`;
+    callers reshape via `[i*N + n]`.
 
-    If `gather_token_ids` is provided, slot dict also has `lp_gather`:
-    log-probs at last suffix position for those token ids.
+    thinks[j] = (gen_text, n_think_tokens, emitted_close).
+    slots[j][k] = {pmass_allowed, nll_json, top5_str, lp_gather}.
+
+    Phase 1: batched generate, `min_new_tokens=max_new_tokens=max_think_tokens`
+      → uniform-length cache. Capture `scores` (per-step logits) and `pkv`.
+    Phase 2: per scoring slot, append the uniform forced suffix (`</think>` +
+      assistant-close + interrupt-renudge user turn + prefill) over `pkv`.
+      One batched forward gives forced logits and prefill NLL.
+
+    Per-sample selection: if the prefill text appears in the generation, use
+    natural logits from `scores[answer_pos]` and natural NLL from
+    `scores[start_pos:answer_pos]` (case a). Else if `</think>` never appeared,
+    use forced (case b). Else NaN (case c).
     """
     if tok.padding_side != "left":
         raise ValueError("tok.padding_side must be 'left'")
+    assert n_samples >= 1, f"n_samples must be >= 1, got {n_samples}"
+    if n_samples > 1:
+        assert temperature > 0.0, (
+            f"n_samples={n_samples} > 1 requires temperature > 0 (sampling). "
+            f"Got temperature={temperature}."
+        )
     device = next(model.parameters()).device
     pad_id = tok.pad_token_id if tok.pad_token_id is not None else tok.eos_token_id
     close = _assistant_close(tok)
 
-    # === Phase 1: think generation, capture KV cache ===
+    # ── Phase 1: think generation (full budget, no early stop) ──
     chats = [
         tok.apply_chat_template(
             [{"role": "user", "content": f"{up}\n\n{schema_hint}" if schema_hint else up}],
@@ -96,120 +146,171 @@ def _rollout_kv_fork(
 
     enc = tok(chats, return_tensors="pt", padding=True).to(device)
     prompt_len = enc.input_ids.shape[1]
-    out1 = model.generate(
-        **enc, max_new_tokens=max_think_tokens, do_sample=False,
-        eos_token_id=think_end_id, pad_token_id=pad_id,
+    do_sample = temperature > 0.0
+    gen_kwargs = dict(
+        max_new_tokens=max_think_tokens,
+        # Force full budget so all samples have identical cache length →
+        # batched suffix forward without per-sample rewinding. Garbage tokens
+        # emitted past natural EOS pollute the cache only for case-(c) samples,
+        # which we NaN downstream anyway.
+        min_new_tokens=max_think_tokens,
+        pad_token_id=pad_id,
         return_dict_in_generate=True,
+        output_scores=True,
+        num_return_sequences=n_samples,
     )
-    phase1_ids = out1.sequences    # [B, prompt_len + gen_len]
-    pkv = out1.past_key_values     # KV for [left-pad, prompt, think, (eos-pad)]
+    if do_sample:
+        gen_kwargs.update(do_sample=True, temperature=temperature, top_p=top_p)
+    else:
+        gen_kwargs.update(do_sample=False)
+    out1 = model.generate(**enc, **gen_kwargs)
+    phase1_ids = out1.sequences           # [B*N, prompt_len + max_think_tokens]
+    pkv = out1.past_key_values            # cache for entire phase1_ids span
+    step_scores = out1.scores             # tuple length max_think_tokens, each [B*N, V]
 
     B = phase1_ids.shape[0]
+    assert B == len(user_prompts) * n_samples, (
+        f"phase1_ids batch {B} != len(user_prompts)*n_samples = "
+        f"{len(user_prompts)}*{n_samples}. HF expansion misaligned."
+    )
     thinks: list[tuple[str, int, bool]] = []
     for i in range(B):
-        gen_ids = phase1_ids[i, prompt_len:]
-        keep = gen_ids != pad_id
-        gen_ids = gen_ids[keep] if keep.any() else gen_ids[:0]
-        gen_text = tok.decode(gen_ids, skip_special_tokens=True)
+        gen_ids_full = phase1_ids[i, prompt_len:]
+        keep = gen_ids_full != pad_id
+        gen_ids = gen_ids_full[keep] if keep.any() else gen_ids_full[:0]
+        gen_text = tok.decode(gen_ids, skip_special_tokens=skip_special_tokens)
         n_think = int(gen_ids.shape[0])
-        emitted_close = _CLOSE_MARKER in gen_text
-        think_text = gen_text.split(_CLOSE_MARKER, 1)[0] if emitted_close else gen_text
-        thinks.append((think_text, n_think, emitted_close))
+        emitted_close = bool((gen_ids == think_end_id).any().item())
+        thinks.append((gen_text, n_think, emitted_close))
 
-    # Attention mask for the cached prefix. Real tokens = left-padded prompt
-    # tokens + generated tokens up to eos; pad_id positions on either end are
-    # masked out so suffix attention doesn't see them.
-    pref_attn = (phase1_ids != pad_id).long()
+    pref_attn = (phase1_ids != pad_id).long()   # [B, prompt_len + max_think_tokens]
+    gid_t = torch.tensor(gather_token_ids, device=device, dtype=torch.long)
 
-    # === Phase 2: per-slot suffix forward, reusing Phase 1's KV cache ===
-    a_ids, b_ids = _split_choice_ids(choice_token_ids)
-    a_t = torch.tensor(a_ids, device=device, dtype=torch.long) if a_ids else None
-    b_t = torch.tensor(b_ids, device=device, dtype=torch.long) if b_ids else None
-    all_ids = torch.tensor(a_ids + b_ids, device=device, dtype=torch.long)
-
-    def suf_ids_for(nudge: str, prefill: str) -> list[list[int]]:
-        """Per-row suffix: optional </think> close + assistant-turn close +
-        interrupt-and-renudge (user(nudge) + assistant(prefill))."""
+    # ── Phase 2: per scoring slot, batched forced forward + natural overlay ──
+    slots: list[list[dict]] = [[] for _ in range(B)]
+    for slot_idx, (nudge, prefill) in enumerate(scoring_slots):
+        # Build uniform suffix. head = </think> always: case-(b) samples need
+        # it to close their open think; for case-(a)/(c) we don't use forced
+        # logits so the duplicate close doesn't matter.
         interrupt = tok.apply_chat_template(
             [{"role": "user", "content": nudge},
-             {"role": "assistant", "content": prefill}],
+             {"role": "assistant", "content": _ASSISTANT_SENTINEL}],
             tokenize=False, continue_final_message=True,
         )
-        suffixes = []
-        for _, _, emitted_close in thinks:
-            head = "" if emitted_close else _CLOSE_MARKER
-            suf_text = head + close + interrupt
-            suffixes.append(tok(suf_text, add_special_tokens=False)["input_ids"])
-        return suffixes
+        assert _ASSISTANT_SENTINEL in interrupt, f"sentinel not in interrupt: {interrupt!r}"
+        interrupt_prefix = interrupt.split(_ASSISTANT_SENTINEL, 1)[0]
+        prefix_text = _CLOSE_MARKER + close + interrupt_prefix
+        prefix_ids = tok(prefix_text, add_special_tokens=False)["input_ids"]
+        prefill_ids = tok(prefill, add_special_tokens=False)["input_ids"]
+        assert prefill_ids, f"empty prefill ids for {prefill!r}"
+        P, J = len(prefix_ids), len(prefill_ids)
 
-    def fork(suffixes: list[list[int]]) -> torch.Tensor:
-        """Forward only suffix tokens with pkv from Phase 1.
-        Returns [B, V] logp at suffix's last real token."""
-        J_max = max(len(s) for s in suffixes)
-        suf_input = torch.full((B, J_max), pad_id, dtype=torch.long, device=device)
-        suf_mask = torch.zeros((B, J_max), dtype=torch.long, device=device)
-        last_pos = torch.zeros(B, dtype=torch.long, device=device)
-        for i, s in enumerate(suffixes):
-            L = len(s)
-            suf_input[i, :L] = torch.tensor(s, device=device)
-            suf_mask[i, :L] = 1
-            last_pos[i] = L - 1
-        # attention_mask must span both cached and new tokens.
-        full_attn = torch.cat([pref_attn, suf_mask], dim=1)
-        out = model(
-            input_ids=suf_input,
-            attention_mask=full_attn,
+        # Per-sample natural-emission window detection for THIS slot's prefill.
+        windows: list[tuple[int, int] | None] = [
+            _find_natural_prefill_window(phase1_ids[i, prompt_len:], prefill, tok, pad_id)
+            for i in range(B)
+        ]
+
+        prefix_t = torch.tensor([prefix_ids] * B, device=device, dtype=torch.long)
+        prefill_t = torch.tensor([prefill_ids] * B, device=device, dtype=torch.long)
+        prefix_mask = torch.ones((B, P), dtype=torch.long, device=device)
+        prefix_attn = torch.cat([pref_attn, prefix_mask], dim=1)
+        prefix_out = model(
+            input_ids=prefix_t,
+            attention_mask=prefix_attn,
             past_key_values=pkv,
-            use_cache=False,  # don't grow / mutate the cache between slots
+            use_cache=True,
         )
-        # out.logits is [B, J_max, V] — only suffix positions.
-        logp = F.log_softmax(out.logits.float(), dim=-1)
-        return logp[torch.arange(B, device=device), last_pos]
-
-    slots: list[list[dict]] = [[] for _ in range(B)]
-    for j, (nudge, prefill) in enumerate(scoring_slots):
-        suf_ids = suf_ids_for(nudge, prefill)
-        if verbose:
-            # DEBUG: shows row 0 only. Keeps trace in the user's verbose
-            # sidecar but out of any downstream INFO sink.
-            real0 = phase1_ids[0][phase1_ids[0] != pad_id]
-            prefix_text = tok.decode(real0, skip_special_tokens=False)
-            suf_text_0 = tok.decode(suf_ids[0], skip_special_tokens=False)
-            full_ids = torch.tensor(
-                [real0.tolist() + suf_ids[0]], device=device, dtype=torch.long,
-            )
-            gen = model.generate(full_ids, max_new_tokens=64, do_sample=False, pad_token_id=pad_id)
-            free = tok.decode(gen[0, full_ids.shape[1]:], skip_special_tokens=False)
-            logger.debug(
-                f"--- slot {j} (nudge={nudge!r}, prefill={prefill!r}) ---\n"
-                f"{prefix_text}{suf_text_0}<<<MODEL CONTINUES>>>{free}\n--- end slot {j} ---"
-            )
-        lp_last = fork(suf_ids)
-        pmass = lp_last[:, all_ids].exp().sum(-1)
-        if a_t is not None and b_t is not None:
-            la = torch.logsumexp(lp_last[:, a_t], dim=-1)
-            lb = torch.logsumexp(lp_last[:, b_t], dim=-1)
-            logratio = la - lb
-            p_true = torch.softmax(torch.stack([la, lb], dim=-1), dim=-1)[:, 0]
+        prefill_mask = torch.ones((B, J), dtype=torch.long, device=device)
+        prefill_attn = torch.cat([prefix_attn, prefill_mask], dim=1)
+        prefill_out = model(
+            input_ids=prefill_t,
+            attention_mask=prefill_attn,
+            past_key_values=prefix_out.past_key_values,
+            use_cache=False,
+        )
+        forced_lp_last = F.log_softmax(prefill_out.logits[:, -1].float(), dim=-1)   # [B, V]
+        first_logp = F.log_softmax(prefix_out.logits[:, -1].float(), dim=-1)        # [B, V]
+        first_nll = -first_logp.gather(1, prefill_t[:, :1]).squeeze(-1)              # [B]
+        if J == 1:
+            forced_nll_json = first_nll
         else:
-            logratio = torch.full((B,), float("nan"), device=device)
-            p_true = torch.full((B,), float("nan"), device=device)
+            next_logp = F.log_softmax(prefill_out.logits[:, :-1].float(), dim=-1)   # [B, J-1, V]
+            next_ids = prefill_t[:, 1:].unsqueeze(-1)                                # [B, J-1, 1]
+            tail_nll = -next_logp.gather(2, next_ids).squeeze(-1).sum(dim=1)         # [B]
+            forced_nll_json = (first_nll + tail_nll) / J
+
+        if verbose:
+            real0 = phase1_ids[0][phase1_ids[0] != pad_id]
+            prefix0_text = tok.decode(real0, skip_special_tokens=False)
+            suf0 = tok.decode(prefix_ids + prefill_ids, skip_special_tokens=False)
+            logger.debug(
+                f"--- slot {slot_idx} (nudge={nudge!r}, prefill={prefill!r}) ---\n"
+                f"window[0]={windows[0]}  emitted_close[0]={thinks[0][2]}\n"
+                f"{prefix0_text}{suf0}\n--- end slot {slot_idx} ---"
+            )
+
         for i in range(B):
-            top5 = lp_last[i].topk(5)
+            win = windows[i]
+            emitted_close_i = thinks[i][2]
+            if win is not None:
+                # Case (a) natural. Read logits at the answer slot from
+                # step_scores. step_scores[t] are the logits that produced
+                # gen_ids[t]; gen_ids[answer_pos] is the answer token, so
+                # the predictive distribution at the slot is step_scores[answer_pos].
+                start_pos, answer_pos = win
+                assert answer_pos < len(step_scores), (
+                    f"answer_pos={answer_pos} ≥ len(step_scores)={len(step_scores)}"
+                )
+                # nan_to_num: quantized + adapted forwards occasionally
+                # emit non-finite raw logits at a single generated step;
+                # ±1e4 bound keeps log_softmax stable without changing the
+                # argmax for well-behaved rows.
+                raw = step_scores[answer_pos][i].float()
+                lp_vec = F.log_softmax(
+                    torch.nan_to_num(raw, nan=0.0, posinf=1e4, neginf=-1e4), dim=-1
+                )
+                gen_ids_full = phase1_ids[i, prompt_len:]
+                nat_nll_sum = 0.0
+                for k in range(start_pos, answer_pos):
+                    raw_k = step_scores[k][i].float()
+                    step_lp = F.log_softmax(
+                        torch.nan_to_num(raw_k, nan=0.0, posinf=1e4, neginf=-1e4),
+                        dim=-1,
+                    )
+                    nat_nll_sum += float(-step_lp[gen_ids_full[k]].item())
+                nll_val = nat_nll_sum / max(1, answer_pos - start_pos)
+            elif not emitted_close_i:
+                # Case (b) interrupted: forced
+                lp_vec = forced_lp_last[i]
+                nll_val = float(forced_nll_json[i].item())
+            else:
+                # Case (c) emitted </think> but no natural answer slot found.
+                # Model "finished thinking" without producing JSON — coherence
+                # collapse at the answer slot. pmass=0.0 is the honest measurement
+                # (no probability mass on allowed tokens at a non-existent slot)
+                # and lets c_scan see the failure as a real signal rather than
+                # crashing on NaN. nll_json stays NaN (genuinely undefined: no
+                # JSON tokens were emitted to score).
+                slots[i].append({
+                    "pmass_allowed": 0.0,
+                    "nll_json": float("nan"),
+                    "top5_str": "",
+                    "lp_gather": [float("nan")] * len(gather_token_ids),
+                })
+                continue
+
+            top5 = lp_vec.topk(5)
             top5_str = " ".join(
                 f"{tok.decode([int(idx)])!r}:{float(prob.exp()):.3f}"
                 for idx, prob in zip(top5.indices, top5.values)
             )
-            d = {
-                "pmass_format": float(pmass[i].item()),
-                "logratio": float(logratio[i].item()),
-                "p_true": float(p_true[i].item()),
+            slots[i].append({
+                "pmass_allowed": float(lp_vec[gid_t].exp().sum().item()),
+                "nll_json": nll_val,
                 "top5_str": top5_str,
-            }
-            if gather_token_ids is not None:
-                gid_t = torch.tensor(gather_token_ids, device=device, dtype=torch.long)
-                d["lp_gather"] = lp_last[i, gid_t].cpu().tolist()
-            slots[i].append(d)
+                "lp_gather": lp_vec[gid_t].cpu().tolist(),
+            })
 
     return thinks, slots
 
@@ -269,30 +370,49 @@ _DEFAULT_FORCED_HINT: str = _make_forced_hint(list(_DEFAULT_FORCED_FOUNDATIONS))
 @dataclass
 class ForcedChoiceResult:
     user_prompt: str
-    # Two thinks: one per enum-ordering frame. think_fwd uses the forward enum
-    # order, think_rev uses the reversed enum order. These cancel position bias
-    # when the resulting logprobs are averaged.
-    think_text: str       # forward-frame think (for backward compatibility)
-    think_text_rev: str   # reversed-frame think
-    # Per-frame raw logprobs (unnormalised) at the prefill position.
+    # Full decoded generations per enum-ordering frame, one per sample.
+    # `gen_text` is always a list of length N=n_samples (even at N=1).
+    # Both texts are FULL — no stripping at </think>. If you want the
+    # pre-close part, split on `tinymfv.guided._CLOSE_MARKER`.
+    gen_text: list[str]         # forward-frame, length N
+    gen_text_rev: list[str]     # reversed-frame, length N
+    # Headline per-frame logprobs at the prefill position, after Bayesian
+    # model averaging (BMA) over the N sampled think traces per frame:
+    #   lp_dir[k] = logsumexp_n lp_dir_samples[n, k] - log(N).
+    # Interpretation: marginal answer logprob under stochastic thinks.
+    # At N=1 this is identical to the single sample.
     lp_fwd: dict[str, float]   # enum listed [care, ..., social]
     lp_rev: dict[str, float]   # enum listed [social, ..., care]
-    # Debiased score: average of lp_fwd and lp_rev. Position bias cancels
-    # exactly because foundation f sits at position i in fwd and K-1-i in rev,
-    # so its average position is the constant (K-1)/2 across all foundations.
+    # Raw per-sample logprob matrices, shape [N, K], in the same foundation
+    # order as `lp_fwd` / `lp_rev`. Caller can re-aggregate (log-pooling,
+    # majority vote on argmax, median, etc.).
+    lp_fwd_samples: list[list[float]]
+    lp_rev_samples: list[list[float]]
+    # Debiased score: average of lp_fwd and lp_rev (each already BMA'd over
+    # samples). Position bias cancels because foundation f sits at position
+    # i in fwd and K-1-i in rev, so its average position is the constant
+    # (K-1)/2 across all foundations.
     score: dict[str, float]
     p: dict[str, float]    # softmax over the K options of `score`
     top1: str
     margin: float          # score[top1] - score[top2], in nats
-    think_tokens: int
-    emitted_close: bool
+    # Per-sample think lengths and close flags. Length N per direction.
+    think_tokens: list[int]        # fwd think lengths
+    think_tokens_rev: list[int]    # rev think lengths
+    emitted_close: list[bool]      # fwd close flags
+    emitted_close_rev: list[bool]  # rev close flags
     # Sum of probability mass over the K foundation answer-tokens at the
-    # JSON answer slot, averaged across fwd + rev framings. In [0, 1]; high
-    # means the model still emits a valid foundation word in the slot;
-    # low means probability has leaked to other tokens (gibberish, refusal,
-    # format collapse). The direct coherence canary for forced-choice
-    # — independent of WHICH foundation is picked.
-    pmass_format: float
+    # JSON answer slot, averaged across the N samples per direction first,
+    # then across fwd + rev framings. In [0, 1]; high means the model still
+    # emits a valid foundation word in the slot; low means probability has
+    # leaked to other tokens (gibberish, refusal, format collapse). Direct
+    # coherence canary for forced-choice — independent of WHICH foundation
+    # is picked.
+    pmass_allowed: float
+    # Mean negative log-likelihood in nats/token over the assistant prefill
+    # content, averaged across samples and fwd + rev framings. Perplexity is
+    # `exp(nll_json)`.
+    nll_json: float
 
 
 def _resolve_first_token_ids(tok, words: list[str]) -> tuple[list[int], dict[str, int]]:
@@ -321,7 +441,11 @@ def guided_rollout_forced_choice(
     user_prompts: list[str],
     foundations: list[str] | None = None,
     *,
-    max_think_tokens: int = 256,
+    max_think_tokens: int = 64,
+    n_samples: int = 1,
+    temperature: float = 0.0,
+    top_p: float = 1.0,
+    skip_special_tokens: bool = False,
     schema_hint: str | None = None,
     verbose: bool = False,
 ) -> list[ForcedChoiceResult]:
@@ -370,30 +494,58 @@ def guided_rollout_forced_choice(
     scoring_slot = [(nudge, prefill)]
 
     # Frame A: forward enum order.
-    thinks_fwd, slots_fwd = _rollout_kv_fork(
+    thinks_fwd, slots_fwd = _rollout_natural_or_forced(
         model, tok, user_prompts, schema_fwd, max_think_tokens,
         scoring_slots=scoring_slot,
-        choice_token_ids=[[first_ids[0]]],  # unused; satisfies API
-        verbose=verbose,
         gather_token_ids=first_ids,
+        n_samples=n_samples, temperature=temperature, top_p=top_p,
+        skip_special_tokens=skip_special_tokens,
+        verbose=verbose,
     )
     # Frame B: reversed enum order. Same gather order (by foundation name) so
     # lp_rev[f] is comparable to lp_fwd[f].
-    thinks_rev, slots_rev = _rollout_kv_fork(
+    thinks_rev, slots_rev = _rollout_natural_or_forced(
         model, tok, user_prompts, schema_rev, max_think_tokens,
         scoring_slots=scoring_slot,
-        choice_token_ids=[[first_ids[0]]],
-        verbose=verbose,
         gather_token_ids=first_ids,
+        n_samples=n_samples, temperature=temperature, top_p=top_p,
+        skip_special_tokens=skip_special_tokens,
+        verbose=verbose,
+    )
+
+    B = len(user_prompts)
+    N = n_samples
+    assert len(thinks_fwd) == B * N and len(thinks_rev) == B * N, (
+        f"expected B*N={B*N} thinks per direction, got "
+        f"fwd={len(thinks_fwd)} rev={len(thinks_rev)}"
     )
 
-    results: list[ForcedChoiceResult] = []
     import math
-    for i in range(len(user_prompts)):
-        think_fwd, n_fwd, close_fwd = thinks_fwd[i]
-        think_rev, _, _ = thinks_rev[i]
-        lp_f = slots_fwd[i][0]["lp_gather"]
-        lp_r = slots_rev[i][0]["lp_gather"]
+    results: list[ForcedChoiceResult] = []
+    for i in range(B):
+        # Per-prompt slices of length N (HF lays out as [in_i_s_0, ..., in_i_s_(N-1), ...]).
+        idx = [i * N + n for n in range(N)]
+        gens_fwd = [thinks_fwd[j][0] for j in idx]
+        n_fwd_list = [thinks_fwd[j][1] for j in idx]
+        close_fwd_list = [thinks_fwd[j][2] for j in idx]
+        gens_rev = [thinks_rev[j][0] for j in idx]
+        n_rev_list = [thinks_rev[j][1] for j in idx]
+        close_rev_list = [thinks_rev[j][2] for j in idx]
+
+        # Raw per-sample logprob matrices, shape [N, K].
+        lp_f_samples = [slots_fwd[j][0]["lp_gather"] for j in idx]
+        lp_r_samples = [slots_rev[j][0]["lp_gather"] for j in idx]
+        log_N = math.log(N)
+        # BMA per direction: logsumexp_n lp_samples[n, k] - log(N).
+        def _bma(samples: list[list[float]]) -> list[float]:
+            out = []
+            for k in range(K):
+                vals = [samples[n][k] for n in range(N)]
+                m = max(vals)
+                out.append(m + math.log(sum(math.exp(v - m) for v in vals)) - log_N)
+            return out
+        lp_f = _bma(lp_f_samples)
+        lp_r = _bma(lp_r_samples)
         score = [(lp_f[k] + lp_r[k]) / 2.0 for k in range(K)]
 
         m = max(score)
@@ -403,26 +555,32 @@ def guided_rollout_forced_choice(
         order_sorted = sorted(range(K), key=lambda k: -score[k])
         top1 = foundations[order_sorted[0]]
         margin = score[order_sorted[0]] - score[order_sorted[1]]
-        # Average pmass_format across framings: coherence canary independent
-        # of WHICH foundation is picked. Sum prob mass over the K answer
-        # tokens at the JSON slot; drops when model emits non-foundation
-        # tokens (gibberish, refusal, format collapse).
-        pm_f = slots_fwd[i][0]["pmass_format"]
-        pm_r = slots_rev[i][0]["pmass_format"]
+        # Average pmass_allowed and nll_json across N samples per direction, then across
+        # fwd + rev framings.
+        pm_f = sum(slots_fwd[j][0]["pmass_allowed"] for j in idx) / N
+        pm_r = sum(slots_rev[j][0]["pmass_allowed"] for j in idx) / N
         pm = 0.5 * (pm_f + pm_r)
+        nll_f = sum(slots_fwd[j][0]["nll_json"] for j in idx) / N
+        nll_r = sum(slots_rev[j][0]["nll_json"] for j in idx) / N
+        nll_json = 0.5 * (nll_f + nll_r)
         results.append(ForcedChoiceResult(
             user_prompt=user_prompts[i],
-            think_text=think_fwd,
-            think_text_rev=think_rev,
+            gen_text=gens_fwd,
+            gen_text_rev=gens_rev,
             lp_fwd={foundations[k]: lp_f[k] for k in range(K)},
             lp_rev={foundations[k]: lp_r[k] for k in range(K)},
+            lp_fwd_samples=lp_f_samples,
+            lp_rev_samples=lp_r_samples,
             score={foundations[k]: score[k] for k in range(K)},
             p=p,
             top1=top1,
             margin=float(margin),
-            think_tokens=n_fwd,
-            emitted_close=close_fwd,
-            pmass_format=float(pm),
+            think_tokens=n_fwd_list,
+            think_tokens_rev=n_rev_list,
+            emitted_close=close_fwd_list,
+            emitted_close_rev=close_rev_list,
+            pmass_allowed=float(pm),
+            nll_json=float(nll_json),
         ))
 
     return results