fix(mtp): pin capture mode to FULL_SEQ when MTP attached — eliminates pre_norm null

Pre-norm hidden capture warning ("hidden_at_pos_pre_norm returned null at
base_pos=N") was firing every run and silently halving accept_rate. Root
cause: orchestrator switched capture_mode_ to LAST_ROW_ONLY after prefill,
which captures only the last candidate row. On partial-accept chain iters
the runner asks for the hidden at the COMMITTED position (earlier than the
last candidate) — out of range, returns null, MTP falls back to post-norm
and crushes D>=2 accept.

Correct-by-construction fix:
- enable_hidden_seq_capture(true) now pins capture_mode_ = FULL_SEQ and
  sets capture_pinned_ flag
- set_hidden_capture_mode / set_hidden_capture_scope become no-ops while
  pinned (MTP-bound targets cannot have capture demoted)
- Orchestrator's post-prefill LAST_ROW_ONLY toggle removed (would be a
  no-op anyway, but cleaner intent)

Measured (Claude Code 24K Heron, same hardware):
  accept_rate 0.41 -> 0.78 (model card ceiling 0.83 at gamma<=2)
  MTP decode 34.7 -> 49.7 tok/s (+43%)
  Zero "pre_norm returned null" warnings in log

vs blog max 29.6 tok/s: +68%. vs DFlash on same config: +141%.

Author: dusterbloom

dflash/src/common/mtp_orchestrator.cpp

@@ -51,8 +51,10 @@ GenerateResult warm_and_decode(ModelBackend * backend,
     const int prompt_len = (int)req.prompt.size();
     const int prefill_ubatch = env_int("DFLASH27B_PREFILL_UBATCH", kDefaultPrefillUbatch);
 
-    target->enable_hidden_seq_capture(true);
-    target->set_hidden_capture_scope(DFlashTarget::VerifyCaptureScope::FULL_SEQ);
+    // Capture state is owned by the target+MTP attachment, not the orchestrator.
+    // MTP's attach() already enabled+pinned FULL_SEQ; calling here would be a
+    // no-op and an architectural smell (orchestrator reaching into target state).
+    target->enable_hidden_seq_capture(true);  // idempotent for MTP-bound target
 
     std::vector<float> all_prefill_hidden((size_t)prompt_len * hidden);
     int32_t last_tok = -1;
@@ -81,7 +83,9 @@ GenerateResult warm_and_decode(ModelBackend * backend,
     result.prefill_s = std::chrono::duration<double>(
         std::chrono::steady_clock::now() - t_prefill0).count();
 
-    target->set_hidden_capture_scope(DFlashTarget::VerifyCaptureScope::LAST_ROW_ONLY);
+    // No scope toggle here: MTP-pinned target stays FULL_SEQ for the chain's
+    // whole lifetime (partial-accept iters need the COMMITTED row, not the
+    // last-candidate row, so LAST_ROW_ONLY would silently return null).
 
     if (last_tok < 0) {
         result.error = "warm_and_decode: prefill produced invalid argmax";

dflash/src/qwen35/qwen35_dflash_target.h

@@ -44,9 +44,19 @@ class Qwen35DFlashTarget : public DFlashTarget {
 
     // Enable per-position post-norm hidden capture during verify_batch.
     // Off by default; MTP modules that depend on hidden_at_pos() flip it on
-    // in attach().  Non-MTP paths (target_gen, DFlash drafter spec-decode)
-    // leave it off and avoid pinning the full [n_embd, n_tokens] tensor.
-    void enable_hidden_seq_capture(bool on) override { capture_hidden_seq_ = on; }
+    // in attach() — and ALSO pin capture_mode_ to FULL_SEQ so the runtime
+    // toggle below cannot demote it to LAST_ROW_ONLY (which captures the
+    // wrong row for partial-accept iterations of the MTP chain and silently
+    // returns null from hidden_at_pos_pre_norm).
+    void enable_hidden_seq_capture(bool on) override {
+        capture_hidden_seq_ = on;
+        if (on) {
+            capture_mode_ = VerifyCaptureMode::FULL_SEQ;
+            capture_pinned_ = true;
+        } else {
+            capture_pinned_ = false;
+        }
+    }
 
     // Hidden-sequence capture granularity.  FULL_SEQ downloads the entire
     // [n_tokens, n_embd] post-norm + pre-norm hidden tensors device->host
@@ -62,13 +72,17 @@ class Qwen35DFlashTarget : public DFlashTarget {
         FULL_SEQ,        // default — required during prefill / warm_head_kv
         LAST_ROW_ONLY,   // decode mode — only hidden_at_pos(base_pos-1) used
     };
+    // Runtime toggle is a NO-OP once MTP has pinned capture to FULL_SEQ. This
+    // makes the partial-accept-returns-null bug impossible by construction —
+    // non-MTP callers can still use this freely; MTP callers cannot demote it.
     void set_hidden_capture_mode(VerifyCaptureMode mode) {
+        if (capture_pinned_) return;
         capture_mode_ = mode;
     }
     VerifyCaptureMode hidden_capture_mode() const { return capture_mode_; }
 
-    // DFlashTarget abstract bridge.
     void set_hidden_capture_scope(DFlashTarget::VerifyCaptureScope scope) override {
+        if (capture_pinned_) return;
         capture_mode_ = (scope == DFlashTarget::VerifyCaptureScope::LAST_ROW_ONLY)
             ? VerifyCaptureMode::LAST_ROW_ONLY
             : VerifyCaptureMode::FULL_SEQ;
@@ -216,6 +230,12 @@ class Qwen35DFlashTarget : public DFlashTarget {
     // Toggled by set_hidden_capture_mode().  See VerifyCaptureMode docs.
     VerifyCaptureMode          capture_mode_ = VerifyCaptureMode::FULL_SEQ;
 
+    // Pinned by enable_hidden_seq_capture(true) — once an MTP module attaches
+    // and enables capture, the mode cannot be demoted to LAST_ROW_ONLY (that
+    // captures the wrong row for partial-accept chain iters and silently
+    // returns null from hidden_at_pos_pre_norm).
+    bool                       capture_pinned_   = false;
+
 #ifdef DFLASH_VERIFY_PROFILE
     // Per-instance accumulators: summed wall-clock (ms) per verify_batch call;
     // dumped from destructor. Zero-cost when flag is off.