cleanup(mlx-fused): strip inert KDBG probe instrumentation; finalize codegen presets

- Remove the KAKEYA_KDBG-gated debug instrumentation (helpers + per-block
  emission + prefill_state/turn_compare) from fused_specdecode.py and
  k3_integrated_niah_eval_mac.py. Investigation complete.
- Keep the production fix (runaway-loop guard) + the --chat-scripted-file /
  --fused-no-loop-guard / --chat-native-ref flags.
- Repoint the two codegen presets to the multi-turn 'explain||code' chat
  (guard-off probe + guard-on validate), accurate descriptions; drop the now-
  unused pow_codegen_longprompt.txt fixture.

On-device (Mac M4): across short/long/multi-turn regimes the engine is coherent
(fused==native); guard-on and guard-off outputs are byte-identical on the
multi-turn code scenario -> the guard is inert on healthy output (no regression)
and the systematic degeneration was already resolved by the wrap fix (#146).

Co-authored-by: FluffyAIcode <FluffyAIcode@users.noreply.github.com>

Author: cursoragent

inference_engine/backends/mlx/fused_specdecode.py

@@ -35,69 +35,6 @@
     restored_prefill_cache,
 )
 
-# region agent log (fused-codegen-degeneration-2815 probe; strip after fix)
-import os as _kdbg_os
-import sys as _kdbg_sys
-import json as _kdbg_json
-
-_KDBG = bool(_kdbg_os.environ.get("KAKEYA_KDBG"))
-
-
-def _kdbg(hyp: str, msg: str, **data: Any) -> None:
-    """Emit one NDJSON probe line to stderr (prefix ``KDBG ``) and, best-effort,
-    to /opt/cursor/logs/debug.log. No-op unless ``KAKEYA_KDBG`` is set, so
-    production behaviour is unchanged."""
-    if not _KDBG:
-        return
-    rec = {"hypothesisId": hyp, "location": "fused_specdecode.py",
-           "message": msg, "data": data}
-    try:
-        _kdbg_sys.stderr.write("KDBG " + _kdbg_json.dumps(rec, ensure_ascii=False) + "\n")
-        _kdbg_sys.stderr.flush()
-    except Exception:
-        pass
-    try:
-        with open("/opt/cursor/logs/debug.log", "a") as _f:
-            _f.write(_kdbg_json.dumps(rec) + "\n")
-    except Exception:
-        pass
-
-
-def _kdbg_cycle(ids: Sequence[int], window: int = 80) -> Tuple[float, int]:
-    """Short-unit cycle metric on the tail of ``ids``: returns
-    ``(cyc_frac, cyc_p)`` where ``cyc_p`` is the period (1..window//3) whose
-    back-to-back repetition covers the largest fraction ``cyc_frac`` of the
-    trailing ``window`` tokens. ~1.0 => the tail is a tight repeating loop."""
-    w = list(ids[-window:])
-    n = len(w)
-    if n < 6:
-        return 0.0, 0
-    best_frac, best_p = 0.0, 0
-    for p in range(1, n // 3 + 1):
-        run, i = 0, n - 1
-        while i - p >= 0 and w[i] == w[i - p]:
-            run += 1
-            i -= 1
-        if run > 0:
-            frac = (run + p) / n
-            if frac > best_frac:
-                best_frac, best_p = frac, p
-    return round(best_frac, 3), best_p
-
-
-def _kdbg_cache_offsets(cache: Any) -> Tuple[Optional[int], Optional[int]]:
-    """(first full-attn KVCache offset, first sliding RotatingKVCache offset)."""
-    off_full = off_rot = None
-    for c in (cache or []):
-        nm = type(c).__name__
-        if off_rot is None and "Rotating" in nm:
-            off_rot = int(getattr(c, "offset", -1))
-        elif off_full is None and "Rotating" not in nm:
-            off_full = int(getattr(c, "offset", -1))
-    return off_full, off_rot
-# endregion
-
-
 # --------------------------------------------------------------------------- #
 # Component A: capture verifier aux-layer hidden states (no transformers
 # `output_hidden_states` on MLX → patch the decoder-layer __call__).
@@ -888,22 +825,6 @@ def fused_specdecode_generate(
                 commit = candidate[:accepted] + [correction]
             generated += commit
             accepts.append(accepted)
-            # region agent log (fused-codegen-degeneration-2815 probe)
-            if _KDBG:
-                off_full, off_rot = _kdbg_cache_offsets(getattr(adapter, "_cache", None))
-                cyc_frac, cyc_p = _kdbg_cycle(generated)
-                # H-D: cache.offset must track committed length (past_len).
-                # off_rot lags by the sliding window (bounded), off_full == past_len.
-                _kdbg("AD", "block",
-                      blk=len(accepts) - 1, base=cstart,
-                      past_len=int(adapter._past_len), gen=len(generated),
-                      off_full=off_full, off_rot=off_rot,
-                      bonus=int(bonus), cand=[int(x) for x in candidate],
-                      n_cand=len(candidate), accepted=int(accepted),
-                      commit=[int(x) for x in commit],
-                      next_argmax=int(argmax_fn(adapter.next_token_logits)),
-                      cyc_frac=cyc_frac, cyc_p=cyc_p)
-            # endregion
             if any(t in eos for t in commit):
                 break
             # Greedy decoding can collapse into a runaway short-period loop (e.g.

inference_engine/bridge/manifest.py

@@ -773,19 +773,13 @@ def _harness_preset(
         ),
         Preset(
             name="mlx-kakeya-codegen-degen-probe",
-            description="DEBUG: full f_θ fused engine on a LONG single-turn prompt "
-                        "(~2k-char PoW explanation + a 'write C code' request, from "
-                        "the committed fixture pow_codegen_longprompt.txt) so the "
-                        "native RotatingKVCache ring is ALREADY WRAPPED at prefill "
-                        "(would_wrap_block0). Short single-turn prompts were proven "
-                        "token-identical to native & coherent; this isolates the "
-                        "long-prompt-prefill regime cheaply (tiny 192-tok budget). "
-                        "KAKEYA_KDBG logs prefill state (prompt_len, any_wrapped, "
-                        "would_wrap_block0, rot/full offsets) + per-block offsets + "
-                        "turn_compare_fused_vs_native. Native-greedy control "
-                        "(--chat-native-ref): native coherent + fused garbled ⇒ "
-                        "long-prompt prefill corrupts logits (engine bug); both "
-                        "degenerate ⇒ bounded-greedy pathology the engine must guard.",
+            description="Regression probe (guard DISABLED): full f_θ fused engine "
+                        "on the multi-turn 'explain PoW || write PoW in C' chat "
+                        "that originally degenerated, with --fused-no-loop-guard so "
+                        "any greedy markdown-marker collapse is observable. Pairs "
+                        "with mlx-kakeya-codegen-guard-validate (guard ENABLED) to "
+                        "show the guard is what keeps the answer clean. On current "
+                        "code (post wrap-fix) both turns stay coherent.",
             command_templates=(
                 (
                     "python3", "scripts/research/k3_integrated_niah_eval_mac.py",
@@ -808,12 +802,13 @@ def _harness_preset(
         Preset(
             name="mlx-kakeya-codegen-guard-validate",
             description="Validate the runaway-loop guard end-to-end: full f_θ fused "
-                        "engine on the same long code prompt (pow_codegen_longprompt"
-                        ".txt) with the guard ENABLED (default). The fused answer "
-                        "must NOT collapse into a marker wall — the guard stops the "
-                        "runaway (stopped_on_runaway) leaving a clean tail — while "
-                        "the native-greedy control (no guard) degenerates, proving "
-                        "the guard is what saves the engine from greedy pathology.",
+                        "engine on the multi-turn 'explain PoW || write PoW in C' "
+                        "chat with the guard ENABLED (production default). The "
+                        "answer must stay coherent and never collapse into a marker "
+                        "wall — if a runaway starts, the guard stops it "
+                        "(stopped_on_runaway) leaving a clean tail. Confirmed "
+                        "coherent on current code; byte-identical to the guard-off "
+                        "probe (the guard is inert on healthy output).",
             command_templates=(
                 (
                     "python3", "scripts/research/k3_integrated_niah_eval_mac.py",

scripts/research/k3_integrated_niah_eval_mac.py

@@ -230,7 +230,6 @@ def main() -> int:
         MLXRestoredIncrementalVerifier, capture_aux_hidden,
         make_bridge_embed_lm_head, fused_specdecode_generate,
         fused_specdecode_generate_mlx, fused_specdecode_generate_mlx_trim,
-        _sliding_ring_would_wrap,  # region agent log (fused-codegen-degeneration-2815)
     )
     from inference_engine.v04.kv_compressor import make_default_compressor
     from inference_engine.bench.k3_report_gate import (
@@ -779,54 +778,6 @@ def _encode_chat(history: List[Dict[str, str]]) -> List[int]:
                         history, add_generation_prompt=True)
                 return list(cids.tolist() if hasattr(cids, "tolist") else cids)
 
-            # region agent log (fused-codegen-degeneration-2815 prefill probe)
-            import os as _kos_chat
-            _KDBG_CHAT = bool(_kos_chat.environ.get("KAKEYA_KDBG"))
-
-            def _kdbg_emit(rec: Dict[str, Any]) -> None:
-                try:
-                    sys.stderr.write("KDBG " + json.dumps(rec, ensure_ascii=False) + "\n")
-                    sys.stderr.flush()
-                except Exception:
-                    pass
-                try:
-                    with open("/opt/cursor/logs/debug.log", "a") as _f:
-                        _f.write(json.dumps(rec) + "\n")
-                except Exception:
-                    pass
-
-            def _kdbg_cache_summary(cache: Any) -> Dict[str, Any]:
-                """rot/full offset+max_size rollup + wrap/trimmable flags. The
-                decisive prefill signal: is the sliding RotatingKVCache already
-                wrapped (off>=max_size) BEFORE decode starts, and does full-attn
-                off == prompt_len? A pre-wrapped ring at prefill means the very
-                first speculative block's trim is refused (offset desync)."""
-                rot_off = rot_ms = full_off = None
-                any_wrapped = False
-                all_trimmable = True
-                n = 0
-                for c in (cache or []):
-                    n += 1
-                    nm = type(c).__name__
-                    off = int(getattr(c, "offset", -1))
-                    ms = getattr(c, "max_size", None)
-                    ms = int(ms) if ms is not None else None
-                    is_rot = "Rotating" in nm
-                    if is_rot and ms is not None and off >= ms:
-                        any_wrapped = True
-                    trim_fn = getattr(c, "is_trimmable", None)
-                    trim = bool(trim_fn()) if callable(trim_fn) else None
-                    if trim is False:
-                        all_trimmable = False
-                    if is_rot and rot_off is None:
-                        rot_off, rot_ms = off, ms
-                    if (not is_rot) and full_off is None:
-                        full_off = off
-                return {"n_layers": n, "rot_off": rot_off, "rot_ms": rot_ms,
-                        "full_off": full_off, "any_wrapped": any_wrapped,
-                        "all_trimmable": all_trimmable}
-            # endregion
-
             def _gen_turn(pid: List[int]) -> Dict[str, Any]:
                 # Opt-in A/B control (--chat-native-ref): a plain NATIVE greedy
                 # AR decode of the SAME prompt for --max-new-tokens. Captured as
@@ -837,14 +788,6 @@ def _gen_turn(pid: List[int]) -> Dict[str, Any]:
                 nref_tokens: List[int] = []
                 if args.chat_native_ref:
                     nref_cache, nref_logits = native_prefill(list(pid))
-                    # region agent log (fused-codegen-degeneration-2815 prefill probe)
-                    if _KDBG_CHAT:
-                        _turn = sum(1 for h in history if h.get("role") == "user")
-                        _kdbg_emit({"hypothesisId": "AE",
-                                    "message": "prefill_state_native",
-                                    "data": {"turn": _turn, "prompt_len": len(pid),
-                                             "cache": _kdbg_cache_summary(nref_cache)}})
-                    # endregion
                     while len(nref_tokens) < args.max_new_tokens:
                         tok = int(mx.argmax(nref_logits).item())
                         nref_tokens.append(tok)
@@ -875,23 +818,6 @@ def _gen_turn(pid: List[int]) -> Dict[str, Any]:
                     restored_v_per_layer=_pad(rv, tsrc, T),
                     evicted_positions=evicted,
                     prefill_chunk_size=args.prefill_chunk_size, full_kv=args.cuda_trim)
-                # region agent log (fused-codegen-degeneration-2815 prefill probe)
-                if _KDBG_CHAT:
-                    _turn = sum(1 for h in history if h.get("role") == "user")
-                    _kdbg_emit({"hypothesisId": "AE",
-                                "message": "prefill_state_fused",
-                                "data": {"turn": _turn, "prompt_len": T,
-                                         "evicted_count": len(evicted),
-                                         "block_size": int(args.block_size),
-                                         "would_wrap_block0": bool(
-                                             _sliding_ring_would_wrap(
-                                                 getattr(adapter, "_cache", None),
-                                                 int(args.block_size))),
-                                         "past_len": int(adapter._past_len),
-                                         "f_theta_ran": bool(f_theta_ran),
-                                         "cache": _kdbg_cache_summary(
-                                             getattr(adapter, "_cache", None))}})
-                # endregion
                 t0 = time.perf_counter()
                 _guard = not args.fused_no_loop_guard
                 if mlx_drafter is not None and args.cuda_trim:
@@ -937,45 +863,6 @@ def _gen_turn(pid: List[int]) -> Dict[str, Any]:
                     res["native_ref_tokens"] = len(nref_tokens)
                 res["resident_kv_bytes"] = int(
                     sum(int(getattr(c, "nbytes", 0)) for c in (adapter._cache or [])))
-                # region agent log (fused-codegen-degeneration-2815 probe)
-                import os as _kos
-                if _kos.environ.get("KAKEYA_KDBG"):
-                    ftoks = [int(t) for t in res.get("tokens", [])]
-                    ntoks = [int(t) for t in nref_tokens]
-                    div = None
-                    for j, (a, b) in enumerate(zip(ftoks, ntoks)):
-                        if a != b:
-                            div = j
-                            break
-                    if div is None:
-                        div = min(len(ftoks), len(ntoks))
-
-                    def _dec(seq):
-                        try:
-                            return tokenizer.decode(seq, skip_special_tokens=True)
-                        except TypeError:
-                            return tokenizer.decode(seq)
-                    rec = {
-                        "hypothesisId": "AC",
-                        "message": "turn_compare_fused_vs_native",
-                        "data": {
-                            "turn": sum(1 for h in history if h.get("role") == "user"),
-                            "fused_n": len(ftoks), "native_n": len(ntoks),
-                            "first_divergence_idx": div,
-                            "fused_div_ctx": ftoks[max(0, div - 8):div + 16],
-                            "native_div_ctx": ntoks[max(0, div - 8):div + 16],
-                            "fused_div_text": _dec(ftoks[max(0, div - 8):div + 16]),
-                            "native_div_text": _dec(ntoks[max(0, div - 8):div + 16]),
-                            "fused_tail": ftoks[-48:],
-                            "native_tail": ntoks[-48:],
-                            "fused_tail_text": _dec(ftoks[-48:]),
-                            "native_tail_text": _dec(ntoks[-48:]),
-                        },
-                    }
-                    sys.stderr.write(
-                        "KDBG " + json.dumps(rec, ensure_ascii=False) + "\n")
-                    sys.stderr.flush()
-                # endregion
                 return res
 
             print(f"[chat] FULL fused engine: verifier={args.verifier_path} "