Upload 4 files

cfg-prompt-forge/README.md

@@ -0,0 +1,166 @@
+# 🔧 CFG & Prompt Forge  v4
+
+> Unified CFG control extension for **stock AUTOMATIC1111 Stable Diffusion WebUI**.
+> Combines the best ideas from 8+ CFG-related extensions into one accordion.
+
+---
+
+## Sources & Credits
+
+| Feature | Ported from |
+|---|---|
+| Step Ranges (Linear / Fixed / Default) | sd-webui-dycfg (guzuligo) |
+| Skimmed CFG Classic & Smooth | sd-webui-skimmed_cfg (Extraltodeus) |
+| Auto CFG, Lerp Uncond, LIR, Subtract Mean | ComfyUI-AutomaticCFG (Extraltodeus) |
+| Smooth Skimmed (interpolated_scales) | pre_cfg_comfy_nodes (Extraltodeus) |
+| Guidance Geometry Skew/Stretch/Squash | NRS — Negative Rejection Steering (Scrag3H1ll) |
+| Reinhard Tonemap, Rescale CFG, Heuristic CFG | CFgfade (Panchovix) |
+| HiRes-pass CFG override | HiresCFG (Panchovix) |
+| Warmup/EndStep/LockAfterEnd, Apply to Pos/Neg, Pass Mode | SEGA v5.1 (continue-revolution) |
+| Core opts direct override | cfg-prompt-forge v1 (original) |
+
+---
+
+## Features
+
+### 📐 Core Sampling Parameters
+Per-generation `override_settings` override — auto-restored after generation.
+
+| Control | `opts` key | Effect |
+|---|---|---|
+| Skip Early CFG | `skip_early_cond` | Fraction of early steps ignoring negative prompt |
+| Prompt Word-Wrap | `comma_padding_backtrack` | CLIP 75-token chunk backtrack |
+| NGMS | `s_min_uncond` | Skip negative when σ < threshold |
+| NGMS All Steps | `s_min_uncond_all` | Skip every matching step |
+
+### 📊 CFG Step Ranges (DyCFG)
+Three step windows with start / end / CFG value / interpolation.
+Interp: **Default** (base), **Linear** (interpolate), **Fixed** (hold last value).
+
+### 📈 CFG Schedule
+8 curve shapes multiplied on top of step-range CFG. Live SVG preview.
+Off / Ramp Up / Ramp Down / Cosine In-Out / Bell / Inv. Bell / Step Up / Step Down.
+
+### 🚀 End-step Boost
+Ramp CFG multiplier from ×1.0 up to Boost× during last N% of steps. Stacks with schedule.
+
+### 🎲 Per-step Jitter
+Random ±% perturbation each step for organic textures.
+
+### 🤖 Auto CFG (ComfyUI-AutomaticCFG)
+Per-latent-channel adaptive CFG. Methods: hard / soft / hard_squared / range.
+When enabled, replaces the combine loop — NRS is bypassed.
+
+### 🔗 Uncond Lerp
+Blend `text_uncond` toward `text_cond` preserving norm.
+Strength 1.0 = no change. <1 weakens negative. >1 exaggerates it.
+
+### 🔬 Skimmed CFG
+Text-embedding-level uncond modification:
+- **Classic** — binary mask on over-aligned dimensions
+- **Smooth** — importance-weighted blend (interpolated_scales)
+
+### ⚡ NRS Guidance Geometry
+Skew / Stretch / Squash on cond noise predictions relative to uncond:
+- **Stretch** — amplify perpendicular component (sharper positive)
+- **Skew** — steer cond away from uncond rejection
+- **Squash** — renormalise back to original cond magnitude
+
+### 🎚 Post-CFG Shaping (inside combine_denoised hook)
+
+| Feature | Effect |
+|---|---|
+| Reinhard Tonemap | Smooth magnitude clamp on noise prediction — prevents "blowout" |
+| Rescale CFG | Match result std to raw cond std — prevents latent inflation |
+| Heuristic CFG | Quantile contrast normalisation — fights cartoon-ification at high CFG |
+| Latent Intensity Rescale | Per-channel topk intensity target |
+| Subtract Latent Mean | Removes spatial mean per batch item — reduces colour drift |
+
+### 🧭 Feature Activation Window (SEGA v5.1)
+
+Controls **when** embedding features (Lerp, Skim) are active and **which branch** they modify.
+
+| Control | Effect |
+|---|---|
+| **Warmup Steps** | Skip embedding features for first N steps (too noisy) |
+| **End Step** | Deactivate after this step (0 = no limit) |
+| **Lock after End** | Once End Step is crossed, stays off permanently — including HR pass |
+| **Apply to Negative** | Lerp/Skim modifies `text_uncond` |
+| **Apply to Positive** | Lerp/Skim also modifies `text_cond` |
+
+**Lock after End** is the key SEGA idea: once the guidance window closes at End Step, the lock is latched (`lock_triggered = True`) and persists through the HiRes pass — so effects stop cleanly even mid-generation.
+
+### 🖼 Pass Mode & HiRes Fix CFG
+
+**Pass Mode** — which denoising pass activates CFG features:
+- `Both passes` — normal (default)
+- `First pass only` — CFG shaping only during base pass; HR pass uses plain defaults
+- `HR pass only` — CFG shaping activates only for HiRes fix
+
+**HR CFG Override** — independently swaps `p.cfg_scale` for the HR pass only.
+Works regardless of Pass Mode. Lower values (1–4) often clean up HiRes upscaling.
+
+---
+
+## Installation
+
+```bash
+cd stable-diffusion-webui/extensions
+git clone <repo-url> cfg-prompt-forge
+```
+
+Or **Extensions → Install from URL** in WebUI.
+
+---
+
+## Recipes
+
+### High-quality portrait
+```
+Skip Early CFG: 0.25  |  NGMS: 0.50
+Schedule: Ramp Down  ×1.6 → ×0.9
+End Boost from 80%  ×1.4
+Reinhard: 4.0
+Warmup: 5 steps  |  End Step: 0 (full)
+Apply to Negative: ✓
+```
+
+### Organic / painterly
+```
+Jitter: ±15%  |  Schedule: Bell ×0.6 → ×1.5
+Skim: Smooth  scale=6.0
+Subtract Mean: ✓  |  Apply to Negative: ✓  |  Apply to Positive: ✓
+Warmup: 8  |  End Step: 25
+```
+
+### Speed run (30 steps)
+```
+Skip Early CFG: 0.40  |  NGMS: 1.20  |  NGMS All Steps: ✓
+Auto CFG: hard  ref=8  (NRS auto-disabled)
+```
+
+### Sharp upscale only during HR
+```
+Pass Mode: HR pass only
+End Boost from 85%  ×1.3
+Rescale CFG: 0.7
+HR CFG Override: 2.0  (also active)
+```
+
+### Lock effects to base pass only, then clean HR
+```
+Pass Mode: First pass only  (schedule/boost off during HR)
+Lock after End: ✓  |  End Step: [last step of base pass]
+HR CFG Override: 3.0
+```
+
+---
+
+## Technical Notes
+
+- **No model patching** — only standard A1111 hooks
+- **`override_settings`** scoped to current generation, auto-restored
+- **`combine_denoised` hook** installed/removed per generation; safe to stack
+- **`lock_triggered`** state survives into HR pass (SEGA v5.1 pattern) — set in `_emb_features_active()`, cleared in `postprocess()`
+- **`in_hr_pass`** flag set in `before_hr()` — allows Pass Mode to discriminate
+- **SDXL compatible** — handles both plain tensor and `{"crossattn": ...}` dict conditioning

cfg-prompt-forge/javascript/cfg_prompt_forge.js

@@ -0,0 +1,74 @@
+/**
+ * CFG & Prompt Forge v4 — UI enhancements
+ * • Blue left-border on accordion when enabled
+ * • Dims sub-sections when their parent Enable checkbox is off
+ * • Status badge in accordion title
+ */
+(function () {
+    "use strict";
+
+    function wireAccordion(accId) {
+        const acc = document.getElementById(accId);
+        if (!acc) return;
+        const mainCb = acc.querySelector('input[type="checkbox"]');
+        const btn    = acc.querySelector("button[aria-expanded], button.label-wrap");
+        if (!mainCb || !btn) return;
+
+        function update() {
+            btn.style.borderLeft    = mainCb.checked ? "3px solid #5bc8f5" : "";
+            btn.style.paddingLeft   = mainCb.checked ? "9px" : "";
+            btn.style.background    = mainCb.checked ? "rgba(91,200,245,.05)" : "";
+        }
+        mainCb.addEventListener("change", update);
+        update();
+    }
+
+    function wireDimming(accId) {
+        const acc = document.getElementById(accId);
+        if (!acc) return;
+
+        // For every checkbox whose label contains "Enable" (but not the master ✦)
+        acc.querySelectorAll('input[type="checkbox"]').forEach(cb => {
+            const lbl = (cb.closest("label") || cb.parentElement || {}).textContent || "";
+            if (!lbl.includes("Enable") || lbl.includes("✦")) return;
+
+            function apply() {
+                // Walk forward siblings until the next Enable checkbox group
+                let el = cb.closest('[class*="row"],[class*="form"],[class*="block"]')
+                         || cb.parentElement;
+                if (!el) return;
+                let sib = el.nextElementSibling;
+                while (sib) {
+                    const nextEn = sib.querySelector('input[type="checkbox"]');
+                    if (nextEn) {
+                        const nt = (nextEn.closest("label") || nextEn.parentElement || {}).textContent || "";
+                        if (nt.includes("Enable")) break;
+                    }
+                    sib.style.opacity       = cb.checked ? "1" : "0.4";
+                    sib.style.pointerEvents = cb.checked ? "" : "none";
+                    sib.style.transition    = "opacity .15s";
+                    sib = sib.nextElementSibling;
+                }
+            }
+            cb.addEventListener("change", apply);
+            apply();
+        });
+    }
+
+    function init() {
+        ["cpf_acc_t2i", "cpf_acc_i2i"].forEach(id => {
+            wireAccordion(id);
+            wireDimming(id);
+        });
+    }
+
+    let tries = 0;
+    const t = setInterval(() => {
+        if (document.getElementById("cpf_acc_t2i") ||
+            document.getElementById("cpf_acc_i2i") ||
+            ++tries > 100) {
+            clearInterval(t);
+            init();
+        }
+    }, 350);
+})();

cfg-prompt-forge/scripts/cfg_prompt_forge.py

@@ -0,0 +1,1926 @@
+"""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║       CFG & Prompt Forge  v4  —  Stable Diffusion WebUI Extension          ║
+║                  Stock A1111 only  (NOT Forge-only APIs)                   ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║  Sources:                                                                   ║
+║  • sd-webui-dycfg          — step-range combine hook                       ║
+║  • sd-webui-skimmed_cfg    — embedding-level uncond mask                   ║
+║  • ComfyUI-AutomaticCFG    — adaptive per-channel CFG, LIR, mean          ║
+║  • pre_cfg_comfy_nodes     — lerp-uncond, smooth-skim math                 ║
+║  • NRS                     — Skew/Stretch/Squash guidance geometry         ║
+║  • CFgfade                 — Reinhard, Rescale, Heuristic CFG              ║
+║  • HiresCFG                — before_hr CFG override                        ║
+║  • SEGA v5.1               — Warmup/EndStep/LockAfterEnd, Apply to        ║
+║                               Positive/Negative, Pass Mode                 ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║  HOOKS                                                                      ║
+║  on_cfg_denoiser  — schedule / boost / jitter / step-range /               ║
+║                     lerp-uncond / skimmed CFG (with SEGA window+lock)      ║
+║  combine_denoised — Auto CFG / NRS / heuristic / Reinhard / Rescale /     ║
+║                     LIR / subtract-mean                                    ║
+║  before_hr        — HR-pass CFG swap + pass-mode arming                   ║
+║  postprocess_image— HR-pass CFG restore                                    ║
+║  before_process   — write override_settings, arm all state                 ║
+║  postprocess      — disarm + unhook                                        ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+"""
+
+import math
+import random
+from typing import Optional
+
+import gradio as gr
+import torch
+
+from modules import scripts, script_callbacks
+from modules.processing import StableDiffusionProcessingTxt2Img
+
+try:
+    from modules.sd_samplers_cfg_denoiser import CFGDenoiser as _DCLS
+except ImportError:
+    _DCLS = None
+
+_EXT   = "CPF"
+_ORIG  = "combine_denoised"
+_SAVED = f"_{_EXT}_saved_{_ORIG}"
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Schedule math
+# ═══════════════════════════════════════════════════════════════════════════
+
+_SCHED: dict = {
+    "off"      : "Off  (flat × 1.0)",
+    "ramp_up"  : "Ramp Up",
+    "ramp_down": "Ramp Down",
+    "cos_up"   : "Cosine Ease-In",
+    "cos_down" : "Cosine Ease-Out",
+    "bell"     : "Bell  (low → high → low)",
+    "inv_bell" : "Inv. Bell  (high → low → high)",
+    "step_up"  : "Step Up  (at midpoint)",
+    "step_down": "Step Down  (at midpoint)",
+}
+_L2K = {v: k for k, v in _SCHED.items()}
+
+# ── Step-schedule curves (used by multiple parameters) ────────────
+_CURVES = [
+    "Off", "Linear Down", "Linear Up", "Cosine Down", "Cosine Up",
+    "Bell", "Inv. Bell", "Step Up", "Step Down",
+    "Power Down", "Power Up", "Repeating", "Sawtooth",
+]
+
+
+def _sm(t, k, mn, mx):
+    t = max(0.0, min(1.0, t))
+    if k == "ramp_up"  : return mn + (mx - mn) * t
+    if k == "ramp_down": return mx - (mx - mn) * t
+    if k == "cos_up"   : return mn + (mx - mn) * (1 - math.cos(math.pi * t)) / 2
+    if k == "cos_down" : return mx - (mx - mn) * (1 - math.cos(math.pi * t)) / 2
+    if k == "bell"     : return mn + (mx - mn) * math.sin(math.pi * t)
+    if k == "inv_bell" : return mx - (mx - mn) * math.sin(math.pi * t)
+    if k == "step_up"  : return mn if t < 0.5 else mx
+    if k == "step_down": return mx if t < 0.5 else mn
+    return 1.0
+
+
+def _schedule_value(base, step, total, curve, min_val, sched_val=2.0):
+    """Apply curve schedule to a float parameter over denoising steps.
+
+    Returns the parameter value at the given step.
+    curve='Off' → returns base unchanged.
+    """
+    if curve == "Off":
+        return base
+    frac = step / max(total - 1, 1)
+    frac = max(0.0, min(1.0, frac))
+
+    if   curve == "Linear Down":    mult = 1.0 - frac
+    elif curve == "Linear Up":      mult = frac
+    elif curve == "Cosine Down":    mult = math.cos(frac * math.pi / 2)
+    elif curve == "Cosine Up":      mult = 1.0 - math.cos(frac * math.pi / 2)
+    elif curve == "Bell":           mult = math.sin(math.pi * frac)
+    elif curve == "Inv. Bell":      mult = 1.0 - math.sin(math.pi * frac)
+    elif curve == "Step Up":        mult = 0.0 if frac < 0.5 else 1.0
+    elif curve == "Step Down":      mult = 1.0 if frac < 0.5 else 0.0
+    elif curve == "Power Down":     mult = 1.0 - math.pow(frac, max(sched_val, 0.1))
+    elif curve == "Power Up":       mult = math.pow(frac, max(sched_val, 0.1))
+    elif curve == "Repeating":      mult = 1.0 - abs(2.0 * ((frac * sched_val) % 1.0) - 1.0)
+    elif curve == "Sawtooth":       mult = (frac * sched_val) % 1.0
+    else:
+        return base
+    return min_val + (base - min_val) * mult
+
+
+def _step_control_val(base_val, step, sc_enabled, r1_start, r1_end, r1_val,
+                       r2_start, r2_end, r2_val, lock, locked, off_val):
+    """NRS-style Individual Step Control with Range1/Range2 + Lock after End.
+
+    Returns (value, new_locked_flag).
+    When locked → (off_val, True).
+    When in range → (range_val, locked unchanged).
+    Otherwise → (base_val, locked unchanged).
+    """
+    if locked:
+        return off_val, True
+    if not sc_enabled:
+        return base_val, False
+
+    def _in(s, e):
+        return s > 0 and step >= s and (e == 0 or step <= e)
+
+    if _in(r1_start, r1_end):
+        return r1_val, False
+    if _in(r2_start, r2_end):
+        return r2_val, False
+
+    if lock:
+        # Only consider finite range ends (>0) for lock triggering.
+        ends = [e for e in (r1_end, r2_end) if e > 0]
+        if ends and step > max(ends):
+            return off_val, True
+    return base_val, False
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Global state
+# ═══════════════════════════════════════════════════════════════════════════
+
+class _S:
+    enabled      : bool  = False
+    # core opts
+    skip_early   : float = 0.0
+    word_wrap    : int   = 20
+    ngms         : float = 0.0
+    ngms_all     : bool  = False
+    # step ranges
+    ranges_en    : bool  = False
+    range_scales : list  = None
+    base_cfg     : float = 7.0
+    # schedule
+    sched_en     : bool  = False
+    sched_k      : str   = "off"
+    sched_min    : float = 0.5
+    sched_max    : float = 1.5
+    # boost
+    boost_en     : bool  = False
+    boost_from   : float = 0.80
+    boost_mul    : float = 1.5
+    # jitter
+    jitter_en    : bool  = False
+    jitter_amt   : float = 0.10
+    # auto cfg
+    autocfg_en     : bool  = False
+    autocfg_method : str   = "hard"
+    autocfg_ref    : float = 8.0
+    autocfg_topk   : float = 0.25
+    # lerp uncond
+    lerp_en      : bool  = False
+    lerp_str     : float = 1.0
+    # skimmed cfg
+    skim_en      : bool  = False
+    skim_mode    : str   = "Classic"
+    skim_scale   : float = 7.0
+    skim_flip    : bool  = False
+    skim_target  : str   = "Uncond"
+    # NRS
+    nrs_en            : bool  = False
+    nrs_skew          : float = 2.0
+    nrs_stretch       : float = 5.0
+    nrs_squash        : float = 0.75
+    # NRS v2 — Vector Softcap (feature 2)
+    nrs_softcap       : float = 0.0
+    nrs_softcap_mode  : str   = "Per Sample"
+    # NRS v2 — Midpoint Refinement / Kohaku RK2 (feature 4)
+    nrs_midpoint      : float = 0.0
+    nrs_midpoint_mode : str   = "Classic"
+    nrs_midpoint_fh   : bool  = True
+    # TCFG — Tangential Damping via SVD (feature 3)
+    tcfg_en           : bool  = False
+    # Disagreement Gate — adaptive skew/stretch (feature 6)
+    dis_en            : bool  = False
+    dis_strength      : float = 0.5
+    dis_threshold     : float = 0.3
+    dis_metric        : str   = "Cosine"
+    # Inter-step smoothing — Momentum + EMA Delta (feature 7)
+    interp_mode       : str   = "None"
+    interp_mom        : float = 0.0
+    interp_ema        : float = 0.5
+    # Runtime context (NOT UI — populated in _on_cfg_denoiser, read in _custom_combine)
+    current_x         : object = None   # noisy latent params.x
+    current_sigma     : object = None   # params.sigma
+    current_step      : int    = 0
+    total_steps       : int    = 20
+    # Inter-step state (reset each generation and each HR pass)
+    _prev_nrs         : object = None
+    _prev_vel         : object = None
+    _prev_delta       : object = None
+    # post-cfg
+    reinhard_en   : bool  = False
+    reinhard_ref  : float = 4.0
+    rescale_en    : bool  = False
+    rescale_mult  : float = 0.7
+    heuristic_en   : bool  = False
+    heuristic_cfg  : float = 5.0
+    heuristic_hstart : float = 0.0
+    lir_en        : bool  = False
+    lir_cfg       : float = 8.0
+    lir_method    : str   = "hard"
+    lir_topk      : float = 0.25
+    mean_en       : bool  = False
+    # ── Step schedules (per-parameter curve over steps) ─────────────────────
+    nrs_sched_curve       : str   = "Off"
+    nrs_sched_min_skew    : float = 0.0
+    nrs_sched_min_stretch : float = 0.0
+    skim_sched_curve      : str   = "Off"
+    skim_sched_min        : float = 1.0
+    lerp_sched_curve      : str   = "Off"
+    lerp_sched_min        : float = 0.5
+    heuristic_sched_curve : str   = "Off"
+    heuristic_sched_min   : float = 1.0
+    # Computed at each step by _on_cfg_denoiser
+    _sched_skim_scale     : float = 0.0
+    _sched_lerp_str       : float = 0.0
+    _sched_nrs_skew       : float = 0.0
+    _sched_nrs_stretch    : float = 0.0
+    _sched_heuristic_cfg  : float = 0.0
+    # ── NRS Individual Step Control (Range1/Range2 + Lock after End) ────────
+    nrs_sc_enabled   : bool  = False
+    nrs_sc_r1_start  : int   = 0
+    nrs_sc_r1_end    : int   = 0
+    nrs_sc_r1_skew   : float = 0.0
+    nrs_sc_r1_stretch: float = 0.0
+    nrs_sc_r2_start  : int   = 0
+    nrs_sc_r2_end    : int   = 0
+    nrs_sc_r2_skew   : float = 0.0
+    nrs_sc_r2_stretch: float = 0.0
+    nrs_sc_lock      : bool  = False
+    nrs_sc_locked    : bool  = False   # runtime flag
+    # ── SEGA-inspired activation window ─────────────────────────────────────
+    warmup_steps   : int  = 0      # first N steps: embedding features inactive
+    end_step       : int  = 0      # 0 = no limit; stop features after this step
+    lock_after_end : bool = False  # once end_step crossed, stay off for HR pass too
+    lock_triggered : bool = False  # runtime flag, NOT a UI control
+    apply_to_pos   : bool = False  # apply Lerp/Skim to text_cond as well
+    apply_to_neg   : bool = True   # apply Lerp/Skim to text_uncond
+    # ── pass mode ────────────────────────────────────────────────────────────
+    pass_mode    : str  = "Both passes"   # "Both passes"/"First pass only"/"HR pass only"
+    in_hr_pass   : bool = False            # runtime flag
+    # HR CFG
+    hr_en        : bool           = False
+    hr_cfg       : float          = 1.0
+    hr_cfg_saved : Optional[float] = None
+
+
+_st = _S()
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  SEGA-inspired activation-window helpers
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _emb_features_active(step: int) -> bool:
+    """
+    Returns True if embedding-level features (Lerp, Skim) should run this step.
+
+    Rules (ported from SEGA v5.1 is_guidance_active + is_locked_after_end):
+      1. Lock triggered (end_step crossed with lock_after_end) → False permanently
+      2. step < warmup_steps → still warming up → False
+      3. end_step > 0 and step > end_step → past window → possibly lock, then False
+    """
+    if _st.lock_triggered:
+        return False
+    if step < _st.warmup_steps:
+        return False
+    if _st.end_step > 0 and step > _st.end_step:
+        if _st.lock_after_end:
+            _st.lock_triggered = True  # permanent for HR pass too
+        return False
+    return True
+
+
+def _pass_features_active() -> bool:
+    """
+    Returns True if CFG-multiplier features (schedule, boost, jitter, ranges)
+    should run given the current pass_mode.
+    """
+    if _st.pass_mode == "First pass only" and _st.in_hr_pass:
+        return False
+    if _st.pass_mode == "HR pass only" and not _st.in_hr_pass:
+        return False
+    return True
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Step-range builder  (DyCFG)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _build_ranges(total, base, rows):
+    scales = ["Default"] * total
+    for (s1, e1, v, intp) in rows:
+        s = max(1, int(s1)); e = int(e1) if int(e1) > 0 else total
+        if e < s: continue
+        v = max(1.0, float(v))
+        for i in range(s - 1, min(e, total)): scales[i] = v
+        for i in range(s - 2, -1, -1):
+            if isinstance(scales[i], str): scales[i] = intp
+            else: break
+    scales = ["Default"] + scales + ["Default"]
+    prev = base
+    for i in range(len(scales)):
+        if   scales[i] == "Default": scales[i] = base
+        elif scales[i] == "Fixed":   scales[i] = prev if isinstance(prev, float) else base
+        if isinstance(scales[i], float): prev = scales[i]
+    i = 0
+    while i < len(scales):
+        if scales[i] == "Linear":
+            pv = scales[i-1] if i > 0 and isinstance(scales[i-1], float) else base
+            j  = i + 1
+            while j < len(scales) and scales[j] == "Linear": j += 1
+            nv = scales[j] if j < len(scales) and isinstance(scales[j], float) else base
+            d  = (nv - pv) / (j - i + 1)
+            for k in range(i, j): scales[k] = pv + (k - i + 1) * d
+            i = j
+        else: i += 1
+    scales = scales[1:-1]
+    return [float(v) if isinstance(v, float) else base for v in scales]
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  AutoCFG helpers  (AutomaticCFG)
+# ═══════════════════════════════════════════════════════════════════════════
+
+@torch.no_grad()
+def _topk_range(flat_ch, method, topk):
+    k   = max(1, int(flat_ch.numel() * topk))
+
+    data = flat_ch.float()
+    if method == "range":
+        data = data - data.mean()
+        mx  = torch.topk(data, k, largest=True ).values.mean().item()
+        mna = torch.topk(data, k, largest=False).values.abs().mean().item()
+    else:
+        mx   = torch.topk(data, k, largest=True ).values.mean().item()
+        mn_v = torch.topk(data, k, largest=False).values
+        mna  = abs(mn_v.mean().item()) if method == "soft" else mn_v.abs().mean().item()
+
+    r   = (mx + mna) / 2.0
+    return r * r if method == "hard_squared" else r
+
+
+@torch.no_grad()
+def _auto_cfg_combine(unc, conds_list, x_out, eff_scale, ref_cfg, method, topk):
+    target = eff_scale / 10.0
+    out    = torch.zeros_like(unc)
+    for i, conds in enumerate(conds_list):
+        u   = unc[i]
+        ref = u.clone()
+        for ci, w in conds: ref = ref + (x_out[ci] - u) * (w * ref_cfg)
+        C   = ref.shape[0]
+        flat = ref.reshape(C, -1)
+        ranges = [_topk_range(flat[c], method, topk) for c in range(C)]
+        out[i] = u.clone()
+        for ci, w in conds:
+            delta = x_out[ci] - u
+            for c in range(C):
+                r = max(ranges[c], 1e-8)
+                out[i][c] = out[i][c] + delta[c] * (w * ref_cfg * target / r)
+    return out
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  NRS v2  (NRS Kohaku Enhanced v3.5 — sigma-aware latent-space math)
+#  Features: proper sigma conversion, Vector Softcap, Midpoint Refinement,
+#  TCFG (SVD tangential damping), Disagreement Gate, Momentum + EMA Delta
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _nrs_log_skip(name, exc=None):
+    """Silent skip — no crash on NRS sub-feature error."""
+    pass
+
+
+def _validate_4d(t, tag=""):
+    return (torch.is_tensor(t) and t.dim() == 4
+            and t.numel() > 0 and torch.isfinite(t).all())
+
+
+@torch.no_grad()
+def _nrs_softcap_vector(v: torch.Tensor, strength: float,
+                         mode: str = "Per Sample") -> torch.Tensor:
+    """
+    Norm-based tanh softcap — preserves direction, compresses magnitude.
+    Source: NRS Kohaku Enhanced v3.5 _nrs_softcap_vector()
+    Near-zero: linear.  Large values: saturate smoothly.
+    """
+    if strength <= 0.0:
+        return v
+    try:
+        eps = 1e-6
+        s   = max(strength, eps)
+        if mode == "Per Channel":
+            v_abs = v.abs()
+            cap   = (v_abs.mean(dim=(2, 3), keepdim=True) * s).clamp(min=eps)
+            ratio = v_abs / cap
+            scale = torch.tanh(ratio) / ratio.clamp(min=eps)
+            result = v * scale
+        elif mode == "Global Batch":
+            v_norm = v.norm(p=2, dim=(1, 2, 3), keepdim=True).clamp(min=eps)
+            cap    = (v_norm.mean() * s).clamp(min=eps)
+            ratio  = v_norm / cap
+            scale  = torch.tanh(ratio) / ratio.clamp(min=eps)
+            result = v * scale
+        else:  # "Per Sample" (default)
+            v_norm = v.norm(p=2, dim=1, keepdim=True).clamp(min=eps)
+            cap    = (v_norm.mean(dim=(2, 3), keepdim=True) * s).clamp(min=eps)
+            ratio  = v_norm / cap
+            scale  = torch.tanh(ratio) / ratio.clamp(min=eps)
+            result = v * scale
+        return result if torch.isfinite(result).all() else v
+    except Exception:
+        return v
+
+
+@torch.no_grad()
+def _nrs_core(x_orig, cond, uncond, sigma,
+              skew: float, stretch: float, squash: float,
+              vector_softcap: float = 0.0,
+              vector_softcap_mode: str = "Per Sample") -> torch.Tensor:
+    """
+    Proper sigma-aware NRS kernel.
+    Source: NRS Kohaku Enhanced v3.5 _nrs_core()
+
+    Converts denoised predictions to NRS-space via sigma, applies
+    Skew/Stretch/Squash geometry, then converts back.
+    Supports v-prediction models (auto-detected via sd_model.parameterization).
+    """
+    if not _validate_4d(x_orig, "nrs_x") or not _validate_4d(cond, "nrs_c"):
+        return cond
+
+    try:
+        # Detect v-prediction model
+        from modules import shared as _shared
+        is_v_pred = (hasattr(_shared.sd_model, "parameterization") and
+                     _shared.sd_model.parameterization == "v")
+    except Exception:
+        is_v_pred = False
+
+    # Normalise sigma to a [1,1,1,1] tensor
+    if isinstance(sigma, torch.Tensor):
+        sig = sigma.flatten()[0].to(cond.dtype)
+    else:
+        sig = torch.tensor(float(sigma), device=cond.device, dtype=cond.dtype)
+    sig = sig.view(1, 1, 1, 1).clamp(min=1e-6)
+    sig_root = (sig ** 2 + 1).sqrt()
+
+    # Convert to NRS geometry space
+    if is_v_pred:
+        nrs_c, nrs_u = cond, uncond
+    else:
+        x_div   = x_orig / (sig ** 2 + 1)
+        factor  = sig / sig_root
+        nrs_c   = x_orig - (x_div - cond   * factor)
+        nrs_u   = x_orig - (x_div - uncond * factor)
+
+    eps = 1e-6
+
+    def _dot(a, b):  return (a * b).sum(dim=1, keepdim=True)
+    def _nrm2(v):    return _dot(v, v)
+
+    c2c    = _nrm2(nrs_c) + eps
+    u2c    = _dot(nrs_u, nrs_c)
+    u_on_c = (u2c / c2c) * nrs_c
+
+    proj_diff = nrs_c - u_on_c
+    if vector_softcap > 0.0:
+        proj_diff = _nrs_softcap_vector(proj_diff, vector_softcap, vector_softcap_mode)
+    stretched = nrs_c + stretch * proj_diff
+
+    u_rej_c = nrs_u - u_on_c
+    if vector_softcap > 0.0:
+        u_rej_c = _nrs_softcap_vector(u_rej_c, vector_softcap, vector_softcap_mode)
+    skewed = stretched - skew * u_rej_c
+
+    # Squash: normalise back to original cond length (L2)
+    c_len     = nrs_c.norm(dim=1, keepdim=True)
+    s_len     = skewed.norm(dim=1, keepdim=True) + eps
+    sq_scale  = ((1.0 - squash) + squash * (c_len / s_len)).clamp(-10.0, 10.0)
+    x_final   = skewed * sq_scale
+
+    if not torch.isfinite(x_final).all():
+        return cond
+
+    # Convert back to denoised space
+    if is_v_pred:
+        return x_final
+    else:
+        return (x_div - (x_orig - x_final)) * (sig_root / sig)
+
+
+@torch.no_grad()
+def _nrs_midpoint_refined(x_orig, cond, uncond, sigma,
+                           skew, stretch, squash,
+                           blend: float = 0.5,
+                           mode: str = "Classic",
+                           first_half_only: bool = True,
+                           step: int = 0, total: int = 20,
+                           softcap: float = 0.0,
+                           softcap_mode: str = "Per Sample") -> torch.Tensor:
+    """
+    Kohaku RK2 midpoint refinement for NRS.
+    Source: NRS Kohaku Enhanced v3.5 calc_nrs_midpoint_refined()
+
+    nrs_direct  = NRS(x, c, u)
+    x_mid       = x + (nrs_direct - x) * blend * 0.5   ← midpoint shift
+    nrs_refined = NRS(x_mid, c, u)
+    result      = (nrs_direct + nrs_refined) / 2        ← RK2 average
+    """
+    def _nrs(x, c, u):
+        return _nrs_core(x, c, u, sigma, skew, stretch, squash, softcap, softcap_mode)
+
+    nrs_direct = _nrs(x_orig, cond, uncond)
+
+    if blend <= 0.0:
+        return nrs_direct
+    if first_half_only and step > total / 2:
+        return nrs_direct
+
+    x_mid = x_orig + (nrs_direct - x_orig) * (blend * 0.5)
+
+    if mode == "Conservative":
+        nrs_ref = _nrs_core(x_mid, cond, uncond, sigma,
+                             skew * 0.75, stretch * 0.75, squash,
+                             softcap, softcap_mode)
+    else:
+        nrs_ref = _nrs(x_mid, cond, uncond)
+
+    if mode == "Directional Midpoint":
+        try:
+            correction  = nrs_ref - nrs_direct
+            base_dir    = nrs_direct - x_orig
+            dims        = tuple(range(1, correction.ndim))
+            guide_norm  = base_dir.norm(p=2, dim=dims, keepdim=True)
+            if torch.any(guide_norm > 1e-6):
+                # Project correction onto base_dir direction
+                c_dot_g = (correction * base_dir).sum(dim=dims, keepdim=True)
+                g_dot_g = (base_dir * base_dir).sum(dim=dims, keepdim=True) + 1e-9
+                c_para  = (c_dot_g / g_dot_g) * base_dir
+                c_orth  = correction - c_para
+                nrs_ref = nrs_direct + c_para + c_orth * 0.75
+        except Exception:
+            pass
+
+    return (nrs_direct + nrs_ref) * 0.5
+
+
+# ── TCFG: Tangential Damping via SVD  (NRS Kohaku #33) ───────────────────
+
+@torch.no_grad()
+def _tcfg_uncond(cond: torch.Tensor, uncond: torch.Tensor,
+                  step: int = -1) -> torch.Tensor:
+    """
+    TCFG: filter tangential components from uncond that are misaligned with cond.
+    Source: arxiv 2503.18137 (Kwon et al., CVPR 2025) / NRS Kohaku apply_tcfg_uncond()
+
+    Algorithm (10 lines):
+      1. Stack [cond, uncond] → [B, 2, N]
+      2. SVD → Vh: [B, 2, N]
+      3. Zero out second right singular vector (tangential)
+      4. Project uncond through zeroed Vh
+    """
+    if not _validate_4d(cond, "tcfg_c") or not _validate_4d(uncond, "tcfg_u"):
+        return uncond
+    if cond.shape != uncond.shape:
+        return uncond
+    orig_dtype  = uncond.dtype
+    orig_device = uncond.device
+    try:
+        if not torch.isfinite(cond).all() or not torch.isfinite(uncond).all():
+            return uncond
+        B = cond.shape[0]
+        cf = cond.float(); uf = uncond.float()
+        all_n  = torch.stack((cf, uf), dim=1).reshape(B, 2, -1)     # [B,2,N]
+        _U, _S, Vh = torch.linalg.svd(all_n, full_matrices=False)    # Vh:[B,2,N]
+        Vh_mod     = Vh.clone(); Vh_mod[:, 1, :] = 0.0
+        uf_flat    = uf.reshape(B, 1, -1)                            # [B,1,N]
+        x_Vh       = torch.matmul(uf_flat, Vh.transpose(-2, -1))     # [B,1,2]
+        result     = torch.matmul(x_Vh, Vh_mod).reshape(*uncond.shape)
+        if not torch.isfinite(result).all():
+            return uncond
+        return result.to(device=orig_device, dtype=orig_dtype)
+    except Exception:
+        return uncond
+
+
+# ── Disagreement Gate  (NRS Kohaku #38) ──────────────────────────────────
+
+@torch.no_grad()
+def _disagreement_gate(cond: torch.Tensor, uncond: torch.Tensor,
+                        skew: float, stretch: float,
+                        strength: float = 0.5, threshold: float = 0.3,
+                        metric: str = "Cosine") -> tuple:
+    """
+    Scale skew/stretch by how much cond and uncond disagree.
+    Source: NRS Kohaku Enhanced apply_disagreement_gate()
+
+    gate = strength + (1 - strength) * clamp(disagreement / threshold, 0, 1)
+    At zero disagreement → gate = strength  (minimum scaling)
+    At full disagreement → gate = 1.0       (full skew/stretch)
+    """
+    if not torch.is_tensor(cond) or not torch.is_tensor(uncond):
+        return skew, stretch
+    try:
+        eps = 1e-6
+        c = cond.float().reshape(cond.shape[0], -1)
+        u = uncond.float().reshape(uncond.shape[0], -1)
+        if metric == "L2":
+            diff_norm = (c - u).norm(p=2, dim=1)
+            ref_norm  = (c.norm(p=2, dim=1) + u.norm(p=2, dim=1)) / 2.0 + eps
+            raw_dist  = (diff_norm / ref_norm).mean().clamp(0.0, 2.0) / 2.0
+        else:  # Cosine
+            cn = torch.nn.functional.normalize(c, dim=1)
+            un = torch.nn.functional.normalize(u, dim=1)
+            raw_dist = ((1.0 - (cn * un).sum(dim=1).mean()) / 2.0).clamp(0.0, 1.0)
+        if not torch.isfinite(raw_dist):
+            return skew, stretch
+        thr  = max(threshold, eps)
+        dis  = float((raw_dist / thr).clamp(0.0, 1.0).item())
+        gate = strength + (1.0 - strength) * dis
+        return skew * gate, stretch * gate
+    except Exception:
+        return skew, stretch
+
+
+# ── Inter-step smoothing: Momentum + EMA Delta  (NRS Kohaku) ─────────────
+
+@torch.no_grad()
+def _apply_momentum(result, prev_result, prev_vel, momentum: float):
+    """
+    RES/Clybius momentum smoothing between denoising steps.
+    Source: NRS Kohaku apply_nrs_momentum()
+    Formula: vel = m*(1-m/2)*prev_vel + (1-m*(1-m/2))*curr_diff
+             result = prev_result + vel
+    Returns (smoothed_result, new_vel)
+    """
+    if momentum <= 0.0 or prev_result is None:
+        curr = result - prev_result if prev_result is not None else None
+        return result, curr
+    try:
+        curr_diff = result - prev_result
+        eff_m     = momentum * (1.0 - momentum * 0.5)
+        vel       = (eff_m * prev_vel + (1.0 - eff_m) * curr_diff
+                     if prev_vel is not None else curr_diff)
+        return prev_result + vel, vel
+    except Exception:
+        return result, None
+
+
+@torch.no_grad()
+def _apply_ema_delta(result, prev_result, prev_delta, ema_alpha: float):
+    """
+    EMA smoothing in update-vector space.
+    Source: NRS Kohaku apply_nrs_ema_delta()
+    Smooths the step-to-step update delta, not the full result tensor.
+    Returns (smoothed_result, new_delta_state)
+    """
+    if prev_result is None:
+        return result, None
+    try:
+        curr_delta  = result - prev_result
+        delta_state = (torch.lerp(prev_delta, curr_delta, ema_alpha)
+                       if prev_delta is not None else curr_delta)
+        return prev_result + delta_state, delta_state
+    except Exception:
+        return result, None
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Skimmed CFG  (sd-webui-skimmed_cfg)
+# ═══════════════════════════════════════════════════════════════════════════
+
+@torch.no_grad()
+def _skim_compute(c, u, cs, ss, no_flip):
+    """Compute skimmed CFG mask.
+    Returns (mask, cond_correction, uncond_correction) where:
+      - cond_correction is subtracted from cond to move it toward uncond
+      - uncond_correction is ADDED to uncond to move it toward cond
+    Formula matches original skimmed_CFG reference with x_orig = uncond."""
+    den  = u - (cs * ((u - c) - (u - u)))
+    ms   = (c - u).sign() == c.sign()
+    md   = c.sign() == (c * cs - u * (cs - 1)).sign()
+    if no_flip:
+        mask = ms & md
+    else:
+        mask = ms & md & (den.sign() == (den - u).sign())
+    low = u - (ss * ((u - c) - (u - u)))
+    # correction for cond (subtract):  (den - low) / cs
+    # correction for uncond (add):     (den - low) / cs  (same magnitude, opposite direction)
+    corr = (den - low) / cs
+    return mask, corr, corr
+
+@torch.no_grad()
+def _skim_smooth(u, c, cs, ss):
+    df = u - cs * c - (cs - 1) * u
+    ds = u - ss * c - (ss - 1) * u
+    ad = (df - ds).abs(); span = ad.max() - ad.min()
+    ad = (ad - ad.min()) / (span + 1e-8)
+    nr = (ss - 1) / max(cs - 1, 1e-6)
+    return (c * (1 - nr) + u * nr) * (1 - ad) + u * ad
+
+
+def _get_emb(raw):
+    """Extract crossattn tensor from raw conditioning (handles SD1.x and SDXL dict)."""
+    if isinstance(raw, dict):
+        return raw.get("crossattn", None)
+    return raw if torch.is_tensor(raw) else None
+
+
+def _set_emb(raw_ref, new_tensor):
+    """Write back modified tensor, preserving dict wrapper for SDXL.
+    NEVER changes the shape of the original — only replaces values in-place."""
+    if isinstance(raw_ref, dict):
+        out = raw_ref.__class__(raw_ref); out["crossattn"] = new_tensor; return out
+    return new_tensor
+
+
+def _emb_window(c: torch.Tensor, u: torch.Tensor):
+    """Return slices of c and u at the MINIMUM shared sequence length.
+    This guarantees we NEVER extend either tensor — A1111 crashes if shape changes."""
+    sl = min(c.shape[1], u.shape[1])
+    return c[:, :sl], u[:, :sl], sl
+
+
+def _apply_skimmed(params) -> None:
+    """Apply Skimmed CFG to text_uncond and/or text_cond.
+    SAFETY: only plain tensors or SDXL dicts are processed; never changes shape.
+    skim_target controls which tensor gets modified:
+      - "Uncond": modify uncond directly (port default, moves uncond toward cond)
+      - "Cond → Uncond": modify cond and assign to uncond (original reference behavior,
+          makes cond≈uncond at mask positions → zero guidance from those positions)
+      - "Both": modify both cond and uncond"""
+    if not _st.apply_to_neg and not _st.apply_to_pos:
+        return
+    rc = params.text_cond
+    ru = params.text_uncond
+    if ru is None:
+        return
+
+    c = _get_emb(rc)
+    u = _get_emb(ru)
+    if c is None or u is None:
+        return
+    if not torch.is_tensor(c) or not torch.is_tensor(u):
+        return
+    if c.dim() != 3 or u.dim() != 3:
+        return
+
+    c_w, u_w, sl = _emb_window(c, u)
+
+    d        = params.denoiser
+    cfg_base = (_st.hr_cfg if (_st.in_hr_pass and _st.hr_en) else _st.base_cfg)
+    cs       = max(d.cond_scale_miltiplier * cfg_base, 1e-6)
+
+    eff_scale = _st._sched_skim_scale
+    if _st.skim_mode == "Smooth":
+        # _skim_smooth always produces a modified uncond
+        new_u_w = _skim_smooth(u_w, c_w, cs, eff_scale)
+        if _st.apply_to_neg:
+            new_u = u.clone()
+            new_u[:, :sl] = new_u_w
+            params.text_uncond = _set_emb(ru, new_u)
+        if _st.apply_to_pos:
+            new_c = c.clone()
+            new_c[:, :sl] = _skim_smooth(c_w, u_w, cs, eff_scale)
+            params.text_cond = _set_emb(rc, new_c)
+        return
+
+    # Classic mode: compute mask + corrections
+    mask, corr_c, corr_u = _skim_compute(c_w, u_w, cs, eff_scale, _st.skim_flip)
+    target = _st.skim_target
+
+    if target == "Cond → Uncond":
+        if _st.apply_to_neg:
+            new_c_for_u = c.clone()
+            new_c_for_u[:, :sl][mask] = c_w[mask] - corr_c[mask]
+            params.text_uncond = _set_emb(ru, new_c_for_u)
+        if _st.apply_to_pos:
+            new_c = c.clone()
+            new_c[:, :sl][mask] = c_w[mask] - corr_c[mask]
+            params.text_cond = _set_emb(rc, new_c)
+
+    elif target == "Uncond":
+        if _st.apply_to_neg:
+            new_u = u.clone()
+            new_u[:, :sl][mask] = u_w[mask] + corr_u[mask]
+            params.text_uncond = _set_emb(ru, new_u)
+        if _st.apply_to_pos:
+            new_c = c.clone()
+            new_c[:, :sl][mask] = c_w[mask] - corr_c[mask]
+            params.text_cond = _set_emb(rc, new_c)
+
+    elif target == "Both":
+        if _st.apply_to_neg:
+            new_u = u.clone()
+            new_u[:, :sl][mask] = u_w[mask] + corr_u[mask] * 0.5
+            params.text_uncond = _set_emb(ru, new_u)
+        if _st.apply_to_pos:
+            new_c = c.clone()
+            new_c[:, :sl][mask] = c_w[mask] - corr_c[mask] * 0.5
+            params.text_cond = _set_emb(rc, new_c)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Lerp Uncond  (AutomaticCFG / pre_cfg_comfy)
+#  Blend text_cond/uncond toward each other, preserving original norm.
+# ═══════════════════════════════════════════════════════════════════════════
+
+@torch.no_grad()
+def _apply_lerp_uncond(params) -> None:
+    rc = params.text_cond
+    ru = params.text_uncond
+    if ru is None:
+        return
+
+    c = _get_emb(rc)
+    u = _get_emb(ru)
+    if c is None or u is None:
+        return
+    if not torch.is_tensor(c) or not torch.is_tensor(u):
+        return
+    if c.dim() != 3 or u.dim() != 3:
+        return
+
+    # Work on MINIMUM shared length only — never extend
+    c_w, u_w, sl = _emb_window(c, u)
+
+    eff_lerp = _st._sched_lerp_str
+    if _st.apply_to_neg:
+        u_norm = u.norm()
+        nu_w   = torch.lerp(c_w, u_w, eff_lerp)
+        nu_n   = nu_w.norm()
+        if nu_n > 1e-8:
+            nu_w = nu_w * (u_norm / nu_n)
+        new_u = u.clone()
+        new_u[:, :sl] = nu_w
+        params.text_uncond = _set_emb(ru, new_u)
+
+    if _st.apply_to_pos:
+        c_norm = c.norm()
+        nc_w   = torch.lerp(u_w, c_w, eff_lerp)
+        nc_n   = nc_w.norm()
+        if nc_n > 1e-8:
+            nc_w = nc_w * (c_norm / nc_n)
+        new_c = c.clone()
+        new_c[:, :sl] = nc_w
+        params.text_cond = _set_emb(rc, new_c)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  on_cfg_denoiser callback  (registered once at import)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _cond_has_shape(v) -> bool:
+    """Return True if v is something A1111 can call .shape[1] on without crashing.
+
+    A1111 sd_samplers_cfg_denoiser.py line 243 does:
+        if tensor.shape[1] == uncond.shape[1] or skip_uncond:
+    When pad_cond_uncond settings are OFF (A1111 default), this is the FIRST
+    place .shape is accessed after our callback.  If v is a dict (SDXL-style
+    conditioning set by another extension) A1111 crashes with:
+        AttributeError: 'dict' object has no attribute 'shape'
+    We guard against that here.
+    """
+    if torch.is_tensor(v):
+        return True
+    if isinstance(v, dict):
+        ca = v.get("crossattn", None)
+        return torch.is_tensor(ca)
+    return hasattr(v, "shape")
+
+
+def _on_cfg_denoiser(params) -> None:
+    if not _st.enabled:
+        return
+
+    d     = params.denoiser
+    total = max(1, params.total_sampling_steps)
+    step  = params.sampling_step
+    t     = step / total
+
+    # Store context needed by _custom_combine (sigma-aware NRS, midpoint, inter-step)
+    _st.current_x     = params.x
+    _st.current_sigma = params.sigma
+    _st.current_step  = step
+    _st.total_steps   = total
+
+    # ── Compute scheduled parameter values for this step ──────────────────
+    _st._sched_skim_scale = _schedule_value(
+        _st.skim_scale, step, total, _st.skim_sched_curve, _st.skim_sched_min)
+    _st._sched_lerp_str = _schedule_value(
+        _st.lerp_str, step, total, _st.lerp_sched_curve, _st.lerp_sched_min)
+    _st._sched_nrs_skew = _schedule_value(
+        _st.nrs_skew, step, total, _st.nrs_sched_curve, _st.nrs_sched_min_skew)
+    _st._sched_nrs_stretch = _schedule_value(
+        _st.nrs_stretch, step, total, _st.nrs_sched_curve, _st.nrs_sched_min_stretch)
+    _st._sched_heuristic_cfg = _schedule_value(
+        _st.heuristic_cfg, step, total, _st.heuristic_sched_curve, _st.heuristic_sched_min)
+
+    # ── NRS Individual Step Control overrides (Range1/Range2 + Lock) ──────
+    _st._sched_nrs_skew, _st.nrs_sc_locked = _step_control_val(
+        _st._sched_nrs_skew, step,
+        _st.nrs_sc_enabled,
+        _st.nrs_sc_r1_start, _st.nrs_sc_r1_end, _st.nrs_sc_r1_skew,
+        _st.nrs_sc_r2_start, _st.nrs_sc_r2_end, _st.nrs_sc_r2_skew,
+        _st.nrs_sc_lock, _st.nrs_sc_locked, off_val=0.0)
+    _st._sched_nrs_stretch, _ = _step_control_val(
+        _st._sched_nrs_stretch, step,
+        _st.nrs_sc_enabled,
+        _st.nrs_sc_r1_start, _st.nrs_sc_r1_end, _st.nrs_sc_r1_stretch,
+        _st.nrs_sc_r2_start, _st.nrs_sc_r2_end, _st.nrs_sc_r2_stretch,
+        _st.nrs_sc_lock, _st.nrs_sc_locked, off_val=0.0)
+
+    # ── Pass-mode gate (schedule / boost / jitter / ranges) ──────────────
+    if _pass_features_active():
+        d.cond_scale_miltiplier = 1.0
+
+        if _st.ranges_en and _st.range_scales and step < len(_st.range_scales):
+            d.cond_scale_miltiplier = _st.range_scales[step] / max(_st.base_cfg, 1e-4)
+
+        if _st.sched_en and _st.sched_k != "off":
+            d.cond_scale_miltiplier *= _sm(t, _st.sched_k, _st.sched_min, _st.sched_max)
+
+        if _st.boost_en and t >= _st.boost_from:
+            ramp = (t - _st.boost_from) / max(1e-9, 1.0 - _st.boost_from)
+            d.cond_scale_miltiplier *= 1.0 + (_st.boost_mul - 1.0) * ramp
+
+        if _st.jitter_en and _st.jitter_amt > 0:
+            d.cond_scale_miltiplier *= 1.0 + random.uniform(-_st.jitter_amt, _st.jitter_amt)
+
+        d.cond_scale_miltiplier = max(0.01, d.cond_scale_miltiplier)
+    else:
+        d.cond_scale_miltiplier = 1.0
+
+    # ── Embedding-level features (SEGA-inspired window + lock guard) ──────
+    if _emb_features_active(step) and _pass_features_active():
+        # SAVE originals — restored on any failure or bad output
+        _orig_cond   = params.text_cond
+        _orig_uncond = params.text_uncond
+
+        # Skip embedding features if text_cond is not in a state we can work with.
+        # Another extension (e.g. NRS Kohaku) may have already turned text_cond
+        # into a plain dict without a "crossattn" key, which would crash A1111
+        # at line 243 of sd_samplers_cfg_denoiser.py regardless of our changes.
+        if not _cond_has_shape(_orig_cond) or not _cond_has_shape(_orig_uncond):
+            return   # don't touch anything — let A1111 handle it
+
+        try:
+            if _st.lerp_en:
+                _apply_lerp_uncond(params)
+            if _st.skim_en:
+                _apply_skimmed(params)
+        except Exception:
+            # On any failure, restore to the guaranteed-valid originals
+            params.text_cond   = _orig_cond
+            params.text_uncond = _orig_uncond
+            return
+
+        # Post-modification validation: ensure we haven't corrupted the shape.
+        # If something produced a non-.shape-able object, roll back.
+        if not _cond_has_shape(params.text_cond):
+            params.text_cond = _orig_cond
+        if not _cond_has_shape(params.text_uncond):
+            params.text_uncond = _orig_uncond
+
+
+script_callbacks.on_cfg_denoiser(_on_cfg_denoiser)
+
+# ── Late-fixup callback (registered lazily in before_process) ────────────────
+# WHY THIS EXISTS:
+# A1111 loads extensions alphabetically.  "cfg-prompt-forge" loads before
+# extensions starting with letters later than 'c' (e.g. "nrs_kohaku…").
+# Callbacks registered at import time fire in registration order, so NRS Kohaku's
+# callback runs AFTER ours.  NRS Kohaku can wrap text_cond in an SDXL-style dict
+# even when the model is SD1.x, causing A1111 line-243 to crash:
+#     if tensor.shape[1] == uncond.shape[1]   →  AttributeError: dict has no .shape
+#
+# Solution: register _late_cond_fixup lazily inside before_process.
+# Because before_process runs AFTER all import-time registrations are done,
+# our fixup is added to the END of the callback list and fires LAST — after
+# every other extension that might corrupt the conditioning.
+
+_fixup_registered: bool = False   # module-level flag: only register once
+
+
+def _late_cond_fixup(params) -> None:
+    """Last-resort fixup with explicit model architecture detection.
+    Unwraps dict-style conditioning back to plain tensors for SD1.x/SD2.x
+    models, while preserving the dict wrapper for SDXL/SD3 models that
+    genuinely require it.
+
+    Previous heuristic checked for "vector" key, but some extensions add
+    a "vector" key to SD1.x conditioning as well, causing false negatives.
+    Using shared.sd_model.is_sdxl / is_sd3 is authoritative.
+    """
+    from modules import shared
+
+    m = getattr(shared, 'sd_model', None)
+    expects_dict = getattr(m, 'is_sdxl', False) or getattr(m, 'is_sd3', False)
+
+    def _try_unwrap(v):
+        if not isinstance(v, dict):
+            return v
+        ca = v.get("crossattn", None)
+        if torch.is_tensor(ca) and not expects_dict:
+            return ca
+        return v
+
+    params.text_cond   = _try_unwrap(params.text_cond)
+    params.text_uncond = _try_unwrap(params.text_uncond)
+
+
+# ═════════════════════════════════════════���═════════════════════════════════
+#  combine_denoised class-patch
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _hook_combine() -> None:
+    if _DCLS is None: return
+    if hasattr(_DCLS, _SAVED):
+        setattr(_DCLS, _ORIG, getattr(_DCLS, _SAVED))
+        delattr(_DCLS, _SAVED)
+    orig = getattr(_DCLS, _ORIG)
+    setattr(_DCLS, _SAVED, orig)
+
+    def _hooked(self, x_out, conds_list, uncond, cond_scale):
+        if not _st.enabled:
+            return orig(self, x_out, conds_list, uncond, cond_scale)
+        try:
+            return _custom_combine(orig, self, x_out, conds_list, uncond, cond_scale)
+        except Exception:
+            return orig(self, x_out, conds_list, uncond, cond_scale)
+
+    setattr(_DCLS, _ORIG, _hooked)
+
+
+def _unhook_combine() -> None:
+    if _DCLS is None: return
+    if hasattr(_DCLS, _SAVED):
+        setattr(_DCLS, _ORIG, getattr(_DCLS, _SAVED))
+        delattr(_DCLS, _SAVED)
+
+
+@torch.no_grad()
+def _custom_combine(orig, self, x_out, conds_list, uncond, cond_scale):
+    # Respect pass_mode
+    if not _pass_features_active():
+        return orig(self, x_out, conds_list, uncond, cond_scale)
+
+    unc       = x_out[-uncond.shape[0]:]
+    # cond_scale already contains cond_scale_miltiplier — A1111 forward() calls
+    # combine_denoised(x_out, conds_list, uncond, cond_scale * self.cond_scale_miltiplier)
+    # so we must NOT multiply by cond_scale_miltiplier again here.
+    eff_scale = cond_scale
+
+    if _st.autocfg_en and _st.autocfg_method != "None":
+        denoised = _auto_cfg_combine(unc, conds_list, x_out, eff_scale,
+                                     _st.autocfg_ref, _st.autocfg_method, _st.autocfg_topk)
+    else:
+        # ── TCFG: filter tangential uncond components before NRS ─────────
+        unc_nrs = unc
+        if _st.tcfg_en and len(conds_list) > 0:
+            try:
+                # Build representative cond tensor (one per batch item)
+                rep_cond = torch.stack(
+                    [x_out[conds_list[i][0][0]] for i in range(unc.shape[0])
+                     if conds_list[i]], dim=0)
+                unc_nrs = _tcfg_uncond(rep_cond, unc, step=_st.current_step)
+            except Exception:
+                unc_nrs = unc
+
+        denoised = torch.clone(unc)
+        sigma    = _st.current_sigma
+        x_orig   = _st.current_x     # noisy latent = params.x = x_in
+
+        # x_in layout: [repeats[0]×x[0], repeats[1]×x[1], ..., x[0], x[1], ...]
+        # The last batch_size entries are the original (unrepeat-ed) noisy latents,
+        # one per batch item.  Using x_orig[i] would give the wrong entry when
+        # repeats[i] > 1 (AND composition).  Use the tail slice instead.
+        x_batch  = (x_orig[-uncond.shape[0]:] if x_orig is not None else None)
+
+        for i, conds in enumerate(conds_list):
+            for ci, w in conds:
+                cp = x_out[ci]
+                up = unc_nrs[i] if _st.tcfg_en else unc[i]
+
+                if _st.nrs_en:
+                    # ── Disagreement Gate: scale skew/stretch adaptively ──
+                    eff_skew, eff_stretch = _st._sched_nrs_skew, _st._sched_nrs_stretch
+                    if _st.dis_en:
+                        eff_skew, eff_stretch = _disagreement_gate(
+                            cp, up,
+                            eff_skew, eff_stretch,
+                            _st.dis_strength, _st.dis_threshold, _st.dis_metric)
+
+                    # ── Proper sigma-aware NRS with optional Midpoint ─────
+                    if sigma is not None and x_batch is not None:
+                        xi  = x_batch[i] if x_batch.shape[0] > i else x_batch[0]
+                        xi  = xi.unsqueeze(0) if xi.dim() == 3 else xi
+                        cp_b = cp.unsqueeze(0) if cp.dim() == 3 else cp
+                        up_b = up.unsqueeze(0) if up.dim() == 3 else up
+
+                        if _st.nrs_midpoint > 0.0:
+                            cp_b = _nrs_midpoint_refined(
+                                xi, cp_b, up_b, sigma,
+                                eff_skew, eff_stretch, _st.nrs_squash,
+                                blend=_st.nrs_midpoint,
+                                mode=_st.nrs_midpoint_mode,
+                                first_half_only=_st.nrs_midpoint_fh,
+                                step=_st.current_step, total=_st.total_steps,
+                                softcap=_st.nrs_softcap,
+                                softcap_mode=_st.nrs_softcap_mode)
+                        else:
+                            cp_b = _nrs_core(xi, cp_b, up_b, sigma,
+                                             eff_skew, eff_stretch, _st.nrs_squash,
+                                             vector_softcap=_st.nrs_softcap,
+                                             vector_softcap_mode=_st.nrs_softcap_mode)
+
+                        cp = cp_b.squeeze(0) if cp_b.shape[0] == 1 else cp_b
+                    else:
+                        # Fallback: simple geometry without sigma (no x_batch stored)
+                        eps = 1e-6
+                        B   = 1; c = cp.reshape(1, -1); u = up.reshape(1, -1)
+                        c2c = (c * c).sum(dim=1, keepdim=True) + eps
+                        u2c = (u * c).sum(dim=1, keepdim=True)
+                        u_on_c    = (u2c / c2c) * c
+                        stretched = c + eff_stretch * (c - u_on_c)
+                        skewed    = stretched - eff_skew * (u - u_on_c)
+                        c_len = c.norm(dim=1, keepdim=True)
+                        s_len = skewed.norm(dim=1, keepdim=True) + eps
+                        cp = (skewed * ((1.0 - _st.nrs_squash)
+                              + _st.nrs_squash * (c_len / s_len))).reshape(cp.shape)
+
+                denoised[i] = denoised[i] + (cp - unc[i]) * (w * eff_scale)
+
+    if _st.heuristic_en:
+        denoised = _heuristic(denoised, unc, eff_scale, _st._sched_heuristic_cfg)
+    if _st.reinhard_en:
+        denoised = _reinhard(denoised, unc, eff_scale, _st.reinhard_ref)
+    if _st.rescale_en:
+        denoised = _rescale(denoised, x_out, conds_list, _st.rescale_mult)
+    if _st.lir_en:
+        denoised = _lir(denoised, _st.lir_cfg, _st.lir_method, _st.lir_topk)
+    if _st.mean_en:
+        dims     = list(range(1, denoised.dim()))
+        denoised = denoised - denoised.mean(dim=dims, keepdim=True)
+
+    # ── Inter-step smoothing (Momentum / EMA Delta) ───────────────────────
+    if _st.interp_mode == "Momentum" and _st.interp_mom > 0.0:
+        denoised, _st._prev_vel = _apply_momentum(
+            denoised, _st._prev_nrs, _st._prev_vel, _st.interp_mom)
+    elif _st.interp_mode == "EMA Delta":
+        denoised, _st._prev_delta = _apply_ema_delta(
+            denoised, _st._prev_nrs, _st._prev_delta, _st.interp_ema)
+
+    _st._prev_nrs = denoised.detach().clone()
+
+    return denoised
+
+
+# ── Post-CFG shapers ──────────────────────────────────────────────────────
+
+@torch.no_grad()
+def _reinhard(result, unc, cs, ref):
+    if cs <= 0: return result
+    noise = result - unc
+    dims  = list(range(1, noise.dim()))
+    mag   = torch.linalg.vector_norm(noise, dim=dims, keepdim=True) + 1e-8
+    unit  = noise / mag
+    mean  = mag.mean(); std = mag.std() if mag.numel() > 1 else torch.zeros_like(mean)
+    top   = (mean + 3.0 * std) * (ref / cs)
+    return unc + unit * (top * mag / (mag + top)) * cs
+
+
+@torch.no_grad()
+def _rescale(result, x_out, conds_list, mult):
+    try:
+        ci   = conds_list[0][0][0]
+        ref  = x_out[ci : ci + 1]
+        dims = list(range(1, result.dim()))
+        sc   = ref.std(dim=dims, keepdim=True) + 1e-8
+        sr   = result.std(dim=dims, keepdim=True) + 1e-8
+        return torch.lerp(result, result * (sc / sr), float(mult))
+    except (IndexError, TypeError): return result
+
+
+@torch.no_grad()
+def _heuristic(result, unc, cs, h_cfg):
+    if cs <= 0 or abs(cs - h_cfg) < 0.05:
+        return result
+    if _st.heuristic_hstart > 0.0 and _st.current_step < _st.heuristic_hstart * _st.total_steps:
+        return result
+    noise = result - unc
+    h_res = unc + h_cfg * noise / cs
+    rQ    = torch.quantile((result - result.mean()).abs().float(), 0.99) + 1e-8
+    hQ    = torch.quantile((h_res  - h_res .mean()).abs().float(), 0.99) + 1e-8
+    return unc + noise * (hQ / rQ)
+
+
+@torch.no_grad()
+def _lir(result, target_cfg, method, topk):
+    target = target_cfg / 10.0
+    out    = result.clone()
+    for b in range(result.shape[0]):
+        flat = result[b].reshape(result[b].shape[0], -1)
+        for c in range(flat.shape[0]):
+            r = max(_topk_range(flat[c], method, topk), 1e-8)
+            out[b][c] = result[b][c] * (target / r)
+    return out
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  SVG schedule preview
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _make_svg(kind, mn, mx, W=340, H=88):
+    PAD = 16; w, h = W - 2*PAD, H - 2*PAD; N = 80
+    y_lo = 0.0; y_hi = max(3.0, float(mx) + 0.4)
+    def px(t, v): return f"{PAD+t*w:.1f},{PAD+(1-(v-y_lo)/(y_hi-y_lo))*h:.1f}"
+    pts = " ".join(px(i/N, _sm(i/N, kind, float(mn), float(mx))) for i in range(N+1))
+    by  = PAD + (1 - (1.0 - y_lo)/(y_hi - y_lo)) * h
+    _, ymn = map(float, px(0.0,  float(mn)).split(","))
+    _, ymx = map(float, px(0.5,  float(mx)).split(","))
+    return (f'<div style="margin:4px 0"><svg xmlns="http://www.w3.org/2000/svg" '
+            f'width="{W}" height="{H}" style="background:#0b0b18;border-radius:8px;'
+            f'border:1px solid #1e1e36;display:block">'
+            f'<line x1="{PAD}" y1="{by:.1f}" x2="{PAD+w}" y2="{by:.1f}" '
+            f'stroke="#3a3a5a" stroke-dasharray="4 3" stroke-width="1"/>'
+            f'<text x="{PAD+3}" y="{by-3:.0f}" fill="#555" font-size="9" font-family="monospace">×1.0</text>'
+            f'<text x="{PAD+3}" y="{ymn+4:.0f}" fill="#6ab4ff" font-size="9" font-family="monospace" opacity=".8">×{float(mn):.2f}</text>'
+            f'<text x="{PAD+3}" y="{ymx-2:.0f}" fill="#6ab4ff" font-size="9" font-family="monospace" opacity=".8">×{float(mx):.2f}</text>'
+            f'<polyline points="{pts}" fill="none" stroke="#5bc8f5" stroke-width="2.2" '
+            f'stroke-linecap="round" stroke-linejoin="round"/>'
+            f'<text x="{PAD}" y="{H-2}" fill="#444" font-size="9" font-family="monospace">0</text>'
+            f'<text x="{PAD+w-28}" y="{H-2}" fill="#444" font-size="9" font-family="monospace">final</text>'
+            f'</svg></div>')
+
+
+def _h(txt):
+    return (f"<div style='font-weight:700;color:#a8d4ff;margin:12px 0 2px;font-size:.9em;"
+            f"letter-spacing:.03em'>{txt}</div>"
+            f"<hr style='border:none;border-top:1px solid #1e1e36;margin:0 0 5px'/>")
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+#  Script
+# ═══════════════════════════════════════════════════════════════════════════
+
+class CFGPromptForge(scripts.Script):
+
+    def title(self):  return "CFG & Prompt Forge"
+    def show(self, _): return scripts.AlwaysVisible
+
+    # ──────────────────────────────────────────────────────────────────────
+    def ui(self, is_img2img):
+        tab = "i2i" if is_img2img else "t2i"
+
+        with gr.Accordion("🔧 CFG & Prompt Forge", open=False,
+                           elem_id=f"cpf_acc_{tab}"):
+
+            enabled = gr.Checkbox(label="✦ Enable  CFG & Prompt Forge",
+                                  value=False, elem_id=f"cpf_en_{tab}")
+
+            # ── 1. CORE OPTS ──────────────────────────────────────────────
+            gr.HTML(_h("📐  Core Sampling Parameters"))
+            with gr.Row():
+                skip_early = gr.Slider(
+                    label="Skip Early CFG", minimum=0.0, maximum=1.0,
+                    step=0.01, value=0.0,
+                    info="Fraction of early steps where negative prompt is ignored.")
+                word_wrap = gr.Slider(
+                    label="Prompt Word-Wrap Limit (tokens)",
+                    minimum=0, maximum=74, step=1, value=20,
+                    info="CLIP 75-token chunk backtrack threshold.")
+            with gr.Row():
+                ngms = gr.Slider(
+                    label="Neg. Guidance Min σ  (NGMS)",
+                    minimum=0.0, maximum=15.0, step=0.01, value=0.0,
+                    info="Skip negative prompt when σ < this.  Try 0.5–1.0.")
+                ngms_all = gr.Checkbox(
+                    label="NGMS: skip every matching step",
+                    value=False)
+
+            # ── 2. STEP RANGES ────────────────────────────────────────────
+            gr.HTML(_h("📊  CFG Step Ranges  (DyCFG)"))
+            ranges_en = gr.Checkbox(label="Enable Step Ranges", value=False)
+            range_rows = []
+            for idx in range(3):
+                with gr.Row():
+                    rs = gr.Number(label=f"#{idx+1} Start", value=0, precision=0, minimum=0, maximum=500)
+                    re = gr.Number(label="End (0=last)",    value=0, precision=0, minimum=0, maximum=500)
+                    rv = gr.Number(label="CFG scale",       value=7.0, precision=2, minimum=1.0, maximum=100.0)
+                    ri = gr.Radio(choices=["Default","Linear","Fixed"], value="Default", label="Interp")
+                range_rows.extend([rs, re, rv, ri])
+
+            # ── 3. SCHEDULE ────────────────────────────────────────────────
+            gr.HTML(_h("📈  CFG Schedule"))
+            sched_en = gr.Checkbox(label="Enable Schedule", value=False)
+            with gr.Row():
+                sched_type = gr.Dropdown(label="Shape",
+                    choices=list(_SCHED.values()), value=_SCHED["off"])
+                sched_min  = gr.Slider(label="Min ×", minimum=0.0, maximum=2.0, step=0.05, value=0.5)
+                sched_max  = gr.Slider(label="Max ×", minimum=0.5, maximum=4.0, step=0.05, value=1.5)
+            sched_svg = gr.HTML(_make_svg("off", 0.5, 1.5))
+            def _upd(lbl, mn, mx): return _make_svg(_L2K.get(lbl, "off"), mn, mx)
+            sched_type.change(_upd, [sched_type, sched_min, sched_max], sched_svg)
+            sched_min .change(_upd, [sched_type, sched_min, sched_max], sched_svg)
+            sched_max .change(_upd, [sched_type, sched_min, sched_max], sched_svg)
+
+            # ── 4. BOOST + JITTER ─────────────────────────────────────────
+            gr.HTML(_h("🚀  End-step Boost  &  🎲  Jitter"))
+            with gr.Row():
+                boost_en   = gr.Checkbox(label="Enable End Boost", value=False)
+                boost_from = gr.Slider(label="Boost From (step fraction)",
+                    minimum=0.5, maximum=0.95, step=0.01, value=0.80,
+                    info="e.g. 0.80 = activates in the last 20% of steps. "
+                         "Max capped at 0.95 — values near 1.0 may never fire "
+                         "on low step counts (with 20 steps, 0.95 fires only on "
+                         "the final step).")
+                boost_mul  = gr.Slider(label="Boost ×",
+                    minimum=1.0, maximum=5.0, step=0.05, value=1.5)
+            with gr.Row():
+                jitter_en  = gr.Checkbox(label="Enable Jitter", value=False)
+                jitter_amt = gr.Slider(label="Jitter Amount (relative ±)",
+                    minimum=0.0, maximum=0.5, step=0.01, value=0.10)
+
+            # ── 5. AUTO CFG ────────────────────────────────────────────────
+            gr.HTML(_h("🤖  Auto CFG  (ComfyUI-AutomaticCFG)"))
+            with gr.Row():
+                autocfg_en     = gr.Checkbox(label="Enable Auto CFG", value=False)
+                autocfg_method = gr.Dropdown(label="Method",
+                    choices=["hard","soft","hard_squared","range"], value="hard")
+            with gr.Row():
+                autocfg_ref  = gr.Slider(label="Reference CFG",
+                    minimum=1.0, maximum=30.0, step=0.5, value=8.0)
+                autocfg_topk = gr.Slider(label="Top-k fraction",
+                    minimum=0.05, maximum=0.5, step=0.01, value=0.25)
+
+            # ── 6. LERP UNCOND ────────────────────────────────────────────
+            gr.HTML(_h("🔗  Uncond Lerp  (AutoCFG / pre_cfg)"))
+            with gr.Row():
+                lerp_en  = gr.Checkbox(label="Enable Uncond Lerp", value=False)
+                lerp_str = gr.Slider(label="Lerp Strength",
+                    minimum=0.0, maximum=3.0, step=0.05, value=1.0,
+                    info="1.0 = no change.  < 1 pulls uncond toward cond.")
+            with gr.Row():
+                lerp_sched_curve = gr.Dropdown(label="Schedule",
+                    choices=_CURVES, value="Off",
+                    info="Curve shape over steps.")
+                lerp_sched_min   = gr.Slider(label="Min Lerp",
+                    minimum=0.0, maximum=3.0, step=0.05, value=0.5,
+                    info="Lerp strength reached at the curve minimum.")
+
+            # ── 7. SKIMMED CFG ────────────────────────────────────────────
+            gr.HTML(_h("🔬  Skimmed CFG  (sd-webui-skimmed_cfg)"))
+            with gr.Row():
+                skim_en   = gr.Checkbox(label="Enable Skimmed CFG", value=False)
+                skim_mode = gr.Radio(choices=["Classic","Smooth"], value="Classic", label="Mode")
+            with gr.Row():
+                skim_scale = gr.Slider(label="Skimming Scale",
+                    minimum=1.0, maximum=20.0, step=0.5, value=7.0)
+                skim_flip  = gr.Checkbox(label="Disable Flipping Filter  (Classic only)", value=False)
+            with gr.Row():
+                skim_sched_curve = gr.Dropdown(label="Schedule",
+                    choices=_CURVES, value="Off",
+                    info="Curve shape over steps.")
+                skim_sched_min   = gr.Slider(label="Min Skim Scale",
+                    minimum=1.0, maximum=20.0, step=0.5, value=1.0,
+                    info="Skim scale reached at the curve minimum.")
+            with gr.Row():
+                skim_target = gr.Radio(
+                    choices=["Uncond", "Cond → Uncond", "Both"],
+                    value="Uncond", label="Classic Target",
+                    info="'Uncond' — modify uncond directly (moves uncond toward cond). "
+                         "'Cond → Uncond' — modify cond, put into uncond (original skimmed-CFG: zero guidance at mask). "
+                         "'Both' — modify both embeddings. Smooth mode always targets the branch selected via Apply-to flags.")
+
+            # ── 8. NRS ────────────────────────────────────────────────────
+            gr.HTML(_h("⚡  Guidance Geometry  —  NRS v2  (NRS Kohaku Enhanced)"))
+            gr.HTML(
+                "<p style='color:#666;font-size:.82em;margin:0 0 5px'>"
+                "Proper sigma-aware NRS on latent noise predictions. "
+                "Includes <b>Vector Softcap</b> (prevent oversteering), "
+                "<b>Midpoint Refinement</b> (Kohaku RK2), "
+                "<b>TCFG</b> (SVD tangential damping), "
+                "<b>Disagreement Gate</b> (adaptive intensity) and "
+                "<b>Inter-step smoothing</b> (Momentum / EMA).</p>"
+            )
+            with gr.Row():
+                nrs_en      = gr.Checkbox(label="Enable NRS Geometry", value=False)
+                nrs_skew    = gr.Slider(label="Skew",    minimum=-10.0, maximum=10.0, step=0.1, value=2.0)
+                nrs_stretch = gr.Slider(label="Stretch", minimum=-10.0, maximum=10.0, step=0.1, value=5.0)
+                nrs_squash  = gr.Slider(label="Squash",  minimum=0.0,   maximum=1.0,  step=0.05, value=0.75)
+            with gr.Row():
+                nrs_sched_curve       = gr.Dropdown(label="Schedule",
+                    choices=_CURVES, value="Off",
+                    info="Curve shape for Skew/Stretch over steps.")
+                nrs_sched_min_skew    = gr.Slider(label="Min Skew",
+                    minimum=-10.0, maximum=10.0, step=0.1, value=0.0,
+                    info="Skew value at the curve minimum.")
+                nrs_sched_min_stretch = gr.Slider(label="Min Stretch",
+                    minimum=-10.0, maximum=10.0, step=0.1, value=0.0,
+                    info="Stretch value at the curve minimum.")
+
+            gr.HTML("<b style='color:#8ab8e8'>Individual Step Control  (NRS-style Range1/Range2 + Lock)</b>"
+                    "<p style='color:#666;font-size:.81em;margin:2px 0 4px'>"
+                    "Override Skew/Stretch with specific values in one or two step ranges. "
+                    "Lock after End: once the last range end is crossed, NRS stays disabled "
+                    "for the rest of the generation (including HR pass).</p>")
+            with gr.Row():
+                nrs_sc_enabled = gr.Checkbox(label="Enable Step Control", value=False)
+                nrs_sc_lock    = gr.Checkbox(label="Lock after End", value=False,
+                    info="Once past last range end, keep NRS disabled permanently.")
+            with gr.Row():
+                nrs_sc_r1_start = gr.Number(label="R1 Start", value=0, precision=0, minimum=0, maximum=500)
+                nrs_sc_r1_end   = gr.Number(label="R1 End (0=last)", value=0, precision=0, minimum=0, maximum=500)
+                nrs_sc_r1_skew    = gr.Slider(label="R1 Skew",    minimum=-10.0, maximum=10.0, step=0.1, value=2.0)
+                nrs_sc_r1_stretch = gr.Slider(label="R1 Stretch", minimum=-10.0, maximum=10.0, step=0.1, value=5.0)
+            with gr.Row():
+                nrs_sc_r2_start = gr.Number(label="R2 Start", value=0, precision=0, minimum=0, maximum=500)
+                nrs_sc_r2_end   = gr.Number(label="R2 End (0=last)", value=0, precision=0, minimum=0, maximum=500)
+                nrs_sc_r2_skew    = gr.Slider(label="R2 Skew",    minimum=-10.0, maximum=10.0, step=0.1, value=1.0)
+                nrs_sc_r2_stretch = gr.Slider(label="R2 Stretch", minimum=-10.0, maximum=10.0, step=0.1, value=2.0)
+
+            gr.HTML("<b style='color:#8ab8e8'>Vector Softcap</b>"
+                    "<p style='color:#666;font-size:.81em;margin:2px 0 4px'>"
+                    "tanh-based direction-preserving magnitude compression. "
+                    "Prevents oversteering at high Skew/Stretch values. 0 = disabled.</p>")
+            with gr.Row():
+                nrs_softcap      = gr.Slider(label="Softcap Strength",
+                    minimum=0.0, maximum=5.0, step=0.1, value=0.0,
+                    info="0 = off. Try 1.0–2.0 as a starting point.")
+                nrs_softcap_mode = gr.Dropdown(label="Softcap Mode",
+                    choices=["Per Sample", "Per Channel", "Global Batch"],
+                    value="Per Sample",
+                    info="Per Sample: recommended. Per Channel: best with high-detail. "
+                         "Global Batch: legacy behaviour.")
+
+            gr.HTML("<b style='color:#8ab8e8'>Midpoint Refinement  (Kohaku RK2)</b>"
+                    "<p style='color:#666;font-size:.81em;margin:2px 0 4px'>"
+                    "Runge-Kutta 2nd-order midpoint correction — computes NRS twice "
+                    "and averages, similar to Kohaku sampler logic. 0 = disabled.</p>")
+            with gr.Row():
+                nrs_midpoint      = gr.Slider(label="Midpoint Blend",
+                    minimum=0.0, maximum=1.0, step=0.05, value=0.0,
+                    info="How far to shift toward midpoint. Try 0.3–0.6.")
+                nrs_midpoint_mode = gr.Dropdown(label="Midpoint Mode",
+                    choices=["Classic", "Conservative", "Directional Midpoint"],
+                    value="Classic",
+                    info="Classic: direct average. Conservative: soften 2nd-pass geometry. "
+                         "Directional: project correction onto base direction.")
+                nrs_midpoint_fh   = gr.Checkbox(
+                    label="First Half Only",
+                    value=True,
+                    info="Only refine during first half of steps (structure phase). "
+                         "Disable to refine all steps.")
+
+            gr.HTML("<b style='color:#8ab8e8'>TCFG — Tangential Damping  (arxiv 2503.18137)</b>"
+                    "<p style='color:#666;font-size:.81em;margin:2px 0 4px'>"
+                    "SVD-based filter: removes uncond components that are tangential "
+                    "(misaligned) to cond. Reduces CFG manifold drift. No extra UNet calls.</p>")
+            tcfg_en = gr.Checkbox(label="Enable TCFG", value=False)
+
+            gr.HTML("<b style='color:#8ab8e8'>Disagreement Gate</b>"
+                    "<p style='color:#666;font-size:.81em;margin:2px 0 4px'>"
+                    "Reduces effective Skew/Stretch when cond and uncond are already "
+                    "similar — avoids pointless NRS on well-aligned guidance.</p>")
+            with gr.Row():
+                dis_en        = gr.Checkbox(label="Enable Disagreement Gate", value=False)
+                dis_strength  = gr.Slider(label="Gate Floor",
+                    minimum=0.0, maximum=1.0, step=0.05, value=0.5,
+                    info="Minimum gate at zero disagreement. 0 = fully blocks NRS when "
+                         "cond≈uncond. 1 = gate has no effect.")
+                dis_threshold = gr.Slider(label="Gate Threshold",
+                    minimum=0.05, maximum=1.0, step=0.05, value=0.3,
+                    info="Disagreement level at which full skew/stretch is reached.")
+                dis_metric    = gr.Radio(choices=["Cosine", "L2"],
+                    value="Cosine", label="Metric",
+                    info="Cosine: direction-based. L2: magnitude-based.")
+
+            gr.HTML("<b style='color:#8ab8e8'>Inter-step Smoothing</b>"
+                    "<p style='color:#666;font-size:.81em;margin:2px 0 4px'>"
+                    "<b>Momentum</b>: RES/Clybius velocity blend between steps — "
+                    "smooths abrupt NRS jumps.<br>"
+                    "<b>EMA Delta</b>: exponential moving average of the step update vector — "
+                    "less temporal blurring than momentum.</p>")
+            with gr.Row():
+                interp_mode = gr.Radio(choices=["None", "Momentum", "EMA Delta"],
+                    value="None", label="Inter-step Mode")
+                interp_mom  = gr.Slider(label="Momentum",
+                    minimum=0.0, maximum=0.99, step=0.01, value=0.0,
+                    info="Higher = more temporal smoothing. 0.5–0.8 typical.")
+                interp_ema  = gr.Slider(label="EMA Alpha",
+                    minimum=0.01, maximum=0.99, step=0.01, value=0.5,
+                    info="Blend factor toward current step. 1.0 = no smoothing.")
+
+            # ── 9. POST-CFG ───────────────────────────────────────────────
+            gr.HTML(_h("🎚  Post-CFG Shaping"))
+            with gr.Row():
+                reinhard_en  = gr.Checkbox(label="Enable Reinhard Tonemap", value=False)
+                reinhard_ref = gr.Slider(label="Reinhard Ref.",
+                    minimum=0.5, maximum=16.0, step=0.5, value=4.0)
+            with gr.Row():
+                rescale_en   = gr.Checkbox(label="Enable Rescale CFG", value=False)
+                rescale_mult = gr.Slider(label="Rescale Strength",
+                    minimum=0.0, maximum=1.0, step=0.05, value=0.7)
+            with gr.Row():
+                heuristic_en  = gr.Checkbox(label="Enable Heuristic CFG", value=False)
+                heuristic_cfg = gr.Slider(label="Heuristic Ref. CFG",
+                    minimum=1.0, maximum=20.0, step=0.5, value=5.0)
+                heuristic_hstart = gr.Slider(label="Heuristic Start Step",
+                    minimum=0.0, maximum=1.0, step=0.01, value=0.0,
+                    info="Fraction of steps before heuristic activates. 0 = from step 0.")
+            with gr.Row():
+                heuristic_sched_curve = gr.Dropdown(label="Schedule",
+                    choices=_CURVES, value="Off",
+                    info="Curve shape for Heuristic CFG over steps.")
+                heuristic_sched_min   = gr.Slider(label="Min Heuristic CFG",
+                    minimum=0.5, maximum=20.0, step=0.5, value=1.0,
+                    info="Heuristic CFG at the curve minimum.")
+            with gr.Row():
+                lir_en     = gr.Checkbox(label="Enable Latent Intensity Rescale", value=False)
+                lir_cfg    = gr.Slider(label="LIR Target CFG",
+                    minimum=1.0, maximum=30.0, step=0.5, value=8.0)
+                lir_method = gr.Dropdown(label="LIR Method",
+                    choices=["hard","soft","hard_squared","range"], value="hard")
+                lir_topk   = gr.Slider(label="LIR Top-k",
+                    minimum=0.05, maximum=0.5, step=0.01, value=0.25)
+            mean_en = gr.Checkbox(label="Enable Subtract Latent Mean", value=False)
+
+            # ── 10. SEGA-INSPIRED ACTIVATION WINDOW ──────────────────────
+            gr.HTML(_h("🧭  Feature Activation Window  (SEGA v5.1)"))
+            gr.HTML(
+                "<p style='color:#666;font-size:.82em;margin:0 0 5px'>"
+                "Controls <em>when</em> embedding-level features (Lerp Uncond, "
+                "Skimmed CFG) are active within a generation, and <em>which</em> "
+                "prompt branch they modify.  Inspired by SEGA's warmup, guidance "
+                "end step, and lock-after-end mechanism.<br><br>"
+                "<b>Warmup Steps</b> — embedding features inactive for the first N steps "
+                "(early steps are too noisy for fine guidance).<br>"
+                "<b>End Step</b> — deactivate embedding features after this step "
+                "(0 = keep active until the end).<br>"
+                "<b>Lock after End</b> — once End Step is crossed the features stay "
+                "off for the rest of the generation, including the HiRes pass.<br>"
+                "<b>Apply to Positive / Negative</b> — choose which prompt branch "
+                "Lerp Uncond and Skimmed CFG modify.</p>"
+            )
+            with gr.Row():
+                warmup_steps   = gr.Slider(label="Warmup Steps",
+                    minimum=0, maximum=50, step=1, value=0,
+                    info="Skip embedding features for first N steps.")
+                end_step       = gr.Slider(label="End Step  (0 = no limit)",
+                    minimum=0, maximum=150, step=1, value=0,
+                    info="Deactivate embedding features after this step.")
+                lock_after_end = gr.Checkbox(
+                    label="Lock after End  (stays off for HR pass too)",
+                    value=False)
+            with gr.Row():
+                apply_to_neg = gr.Checkbox(
+                    label="Apply to Negative  (text_uncond)",
+                    value=True,
+                    info="Lerp Uncond and Skimmed CFG modify the negative/unconditional "
+                         "prompt embeddings.")
+                apply_to_pos = gr.Checkbox(
+                    label="Apply to Positive  (text_cond)",
+                    value=False,
+                    info="Lerp Uncond and Skimmed CFG also modify the positive/conditional "
+                         "prompt embeddings.")
+
+            # ── 11. PASS MODE + HIRES ────────────────────────────────────
+            gr.HTML(_h("🖼  Pass Mode  &  HiRes Fix CFG"))
+            gr.HTML(
+                "<p style='color:#666;font-size:.82em;margin:0 0 5px'>"
+                "<b>Pass Mode</b> — controls during which denoising pass CFG "
+                "features (schedule, boost, jitter, step-ranges, embedding features) "
+                "are active.  Useful when you want aggressive shaping only on the "
+                "base pass and clean defaults on the HiRes upscale pass, or vice versa.<br><br>"
+                "<b>HR CFG Override</b> — separately swap <code>p.cfg_scale</code> "
+                "for the HiRes fix second pass (txt2img only).  Works independently "
+                "of Pass Mode.</p>"
+            )
+            with gr.Row():
+                pass_mode = gr.Radio(
+                    choices=["Both passes", "First pass only", "HR pass only"],
+                    value="Both passes",
+                    label="Pass Mode",
+                    elem_id=f"cpf_passmode_{tab}")
+            with gr.Row():
+                hr_en  = gr.Checkbox(label="Override HR CFG", value=False)
+                hr_cfg = gr.Slider(label="CFG for HR pass",
+                    minimum=1.0, maximum=30.0, step=0.1, value=1.0)
+
+        self.infotext_fields = [
+            (skip_early, "CPF SkipEarlyCFG"),
+            (ngms,       "CPF NGMS"),
+            (hr_cfg,     "CPF HR_CFG"),
+        ]
+
+        # !! ORDER must EXACTLY match _parse_args() !!
+        return [
+            enabled,
+            skip_early, word_wrap, ngms, ngms_all,
+            ranges_en, *range_rows,                   # 1 + 12
+            sched_en, sched_type, sched_min, sched_max,
+            boost_en, boost_from, boost_mul,
+            jitter_en, jitter_amt,
+            autocfg_en, autocfg_method, autocfg_ref, autocfg_topk,
+            lerp_en, lerp_str,
+            lerp_sched_curve, lerp_sched_min,
+            skim_en, skim_mode, skim_scale, skim_flip, skim_target,
+            skim_sched_curve, skim_sched_min,
+            nrs_en, nrs_skew, nrs_stretch, nrs_squash,
+            nrs_sched_curve, nrs_sched_min_skew, nrs_sched_min_stretch,
+            nrs_sc_enabled, nrs_sc_lock,
+            nrs_sc_r1_start, nrs_sc_r1_end, nrs_sc_r1_skew, nrs_sc_r1_stretch,
+            nrs_sc_r2_start, nrs_sc_r2_end, nrs_sc_r2_skew, nrs_sc_r2_stretch,
+            nrs_softcap, nrs_softcap_mode,
+            nrs_midpoint, nrs_midpoint_mode, nrs_midpoint_fh,
+            tcfg_en,
+            dis_en, dis_strength, dis_threshold, dis_metric,
+            interp_mode, interp_mom, interp_ema,
+            reinhard_en, reinhard_ref,
+            rescale_en, rescale_mult,
+            heuristic_en, heuristic_cfg, heuristic_hstart,
+            heuristic_sched_curve, heuristic_sched_min,
+            lir_en, lir_cfg, lir_method, lir_topk,
+            mean_en,
+            warmup_steps, end_step, lock_after_end,   # ← SEGA window
+            apply_to_neg, apply_to_pos,               # ← SEGA branch flags
+            pass_mode,                                 # ← pass mode
+            hr_en, hr_cfg,
+        ]
+
+    # ──────────────────────────────────────────────────────────────────────
+    @staticmethod
+    def _parse_args(raw):
+        it = iter(raw); n = lambda: next(it)
+        return dict(
+            enabled    = n(),
+            skip_early = n(), word_wrap = n(), ngms = n(), ngms_all = n(),
+            ranges_en  = n(),
+            ranges     = [(int(n()), int(n()), float(n()), n()) for _ in range(3)],
+            sched_en   = n(), sched_type = n(), sched_min = n(), sched_max = n(),
+            boost_en   = n(), boost_from = n(), boost_mul = n(),
+            jitter_en  = n(), jitter_amt = n(),
+            autocfg_en = n(), autocfg_method = n(), autocfg_ref = n(), autocfg_topk = n(),
+            lerp_en    = n(), lerp_str = n(),
+            lerp_sched_curve = n(), lerp_sched_min = n(),
+            skim_en    = n(), skim_mode = n(), skim_scale = n(), skim_flip = n(), skim_target = n(),
+            skim_sched_curve = n(), skim_sched_min = n(),
+            nrs_en     = n(), nrs_skew  = n(), nrs_stretch = n(), nrs_squash = n(),
+            nrs_sched_curve = n(), nrs_sched_min_skew = n(), nrs_sched_min_stretch = n(),
+            nrs_sc_enabled = n(), nrs_sc_lock = n(),
+            nrs_sc_r1_start = n(), nrs_sc_r1_end = n(), nrs_sc_r1_skew = n(), nrs_sc_r1_stretch = n(),
+            nrs_sc_r2_start = n(), nrs_sc_r2_end = n(), nrs_sc_r2_skew = n(), nrs_sc_r2_stretch = n(),
+            nrs_softcap = n(), nrs_softcap_mode = n(),
+            nrs_midpoint = n(), nrs_midpoint_mode = n(), nrs_midpoint_fh = n(),
+            tcfg_en    = n(),
+            dis_en = n(), dis_strength = n(), dis_threshold = n(), dis_metric = n(),
+            interp_mode = n(), interp_mom = n(), interp_ema = n(),
+            reinhard_en = n(), reinhard_ref = n(),
+            rescale_en  = n(), rescale_mult  = n(),
+            heuristic_en = n(), heuristic_cfg = n(), heuristic_hstart = n(),
+            heuristic_sched_curve = n(), heuristic_sched_min = n(),
+            lir_en = n(), lir_cfg = n(), lir_method = n(), lir_topk = n(),
+            mean_en       = n(),
+            warmup_steps  = n(), end_step = n(), lock_after_end = n(),
+            apply_to_neg  = n(), apply_to_pos = n(),
+            pass_mode     = n(),
+            hr_en = n(), hr_cfg = n(),
+        )
+
+    # ──────────────────────────────────────────────────────────────────────
+    def before_process(self, p, *args):
+        global _fixup_registered
+        _st.enabled = False
+        try:
+            v = self._parse_args(args)
+        except StopIteration:
+            return
+        if not v["enabled"]:
+            return
+
+        # ── Register late fixup once per session ──────────────────────────────
+        # Done here (not at import) so it's appended AFTER all other extensions'
+        # import-time callbacks → guaranteed to fire last every step.
+        if not _fixup_registered:
+            script_callbacks.on_cfg_denoiser(_late_cond_fixup)
+            _fixup_registered = True
+
+        p.override_settings["skip_early_cond"]         = float(v["skip_early"])
+        p.override_settings["comma_padding_backtrack"]  = int  (v["word_wrap"])
+        p.override_settings["s_min_uncond"]             = float(v["ngms"])
+        p.override_settings["s_min_uncond_all"]         = bool (v["ngms_all"])
+
+        _st.base_cfg     = float(p.cfg_scale)
+        _st.ranges_en    = bool(v["ranges_en"])
+        _st.range_scales = None
+        if _st.ranges_en:
+            active = [(s, e, val, i) for (s, e, val, i) in v["ranges"] if int(s) > 0 or int(e) > 0]
+            if active:
+                _st.range_scales = _build_ranges(p.steps, _st.base_cfg, active)
+
+        _st.sched_en  = bool(v["sched_en"])
+        _st.sched_k   = _L2K.get(v["sched_type"], "off")
+        _st.sched_min = float(v["sched_min"])
+        _st.sched_max = float(v["sched_max"])
+
+        _st.boost_en   = bool (v["boost_en"])
+        _st.boost_from = float(v["boost_from"])
+        _st.boost_mul  = float(v["boost_mul"])
+        _st.jitter_en  = bool (v["jitter_en"])
+        _st.jitter_amt = float(v["jitter_amt"])
+
+        _st.autocfg_en     = bool (v["autocfg_en"])
+        _st.autocfg_method = v["autocfg_method"]
+        _st.autocfg_ref    = float(v["autocfg_ref"])
+        _st.autocfg_topk   = float(v["autocfg_topk"])
+
+        _st.lerp_en  = bool (v["lerp_en"])
+        _st.lerp_str = float(v["lerp_str"])
+        _st.lerp_sched_curve = v.get("lerp_sched_curve", "Off")
+        _st.lerp_sched_min   = float(v.get("lerp_sched_min", 0.5))
+
+        _st.skim_en    = bool (v["skim_en"])
+        _st.skim_mode  = v["skim_mode"]
+        _st.skim_scale = float(v["skim_scale"])
+        _st.skim_flip   = bool (v["skim_flip"])
+        _st.skim_target = v["skim_target"]
+        _st.skim_sched_curve = v.get("skim_sched_curve", "Off")
+        _st.skim_sched_min   = float(v.get("skim_sched_min", 1.0))
+
+        _st.nrs_en      = bool (v["nrs_en"])
+        _st.nrs_skew    = float(v["nrs_skew"])
+        _st.nrs_stretch = float(v["nrs_stretch"])
+        _st.nrs_squash  = float(v["nrs_squash"])
+        _st.nrs_sched_curve       = v.get("nrs_sched_curve", "Off")
+        _st.nrs_sched_min_skew    = float(v.get("nrs_sched_min_skew", 0.0))
+        _st.nrs_sched_min_stretch = float(v.get("nrs_sched_min_stretch", 0.0))
+        _st.nrs_sc_enabled   = bool(v.get("nrs_sc_enabled", False))
+        _st.nrs_sc_lock      = bool(v.get("nrs_sc_lock", False))
+        _st.nrs_sc_locked    = False  # always reset at generation start
+        _st.nrs_sc_r1_start  = int(v.get("nrs_sc_r1_start", 0))
+        _st.nrs_sc_r1_end    = int(v.get("nrs_sc_r1_end", 0))
+        _st.nrs_sc_r1_skew   = float(v.get("nrs_sc_r1_skew", 2.0))
+        _st.nrs_sc_r1_stretch= float(v.get("nrs_sc_r1_stretch", 5.0))
+        _st.nrs_sc_r2_start  = int(v.get("nrs_sc_r2_start", 0))
+        _st.nrs_sc_r2_end    = int(v.get("nrs_sc_r2_end", 0))
+        _st.nrs_sc_r2_skew   = float(v.get("nrs_sc_r2_skew", 1.0))
+        _st.nrs_sc_r2_stretch= float(v.get("nrs_sc_r2_stretch", 2.0))
+        # NRS v2
+        _st.nrs_softcap       = float(v["nrs_softcap"])
+        _st.nrs_softcap_mode  = v["nrs_softcap_mode"]
+        _st.nrs_midpoint      = float(v["nrs_midpoint"])
+        _st.nrs_midpoint_mode = v["nrs_midpoint_mode"]
+        _st.nrs_midpoint_fh   = bool (v["nrs_midpoint_fh"])
+        # TCFG
+        _st.tcfg_en  = bool(v["tcfg_en"])
+        # Disagreement Gate
+        _st.dis_en        = bool (v["dis_en"])
+        _st.dis_strength  = float(v["dis_strength"])
+        _st.dis_threshold = float(v["dis_threshold"])
+        _st.dis_metric    = v["dis_metric"]
+        # Inter-step smoothing
+        _st.interp_mode = v["interp_mode"]
+        _st.interp_mom  = float(v["interp_mom"])
+        _st.interp_ema  = float(v["interp_ema"])
+        # Reset inter-step runtime state at start of generation
+        _st._prev_nrs   = None
+        _st._prev_vel   = None
+        _st._prev_delta = None
+        # Reset context (will be populated by on_cfg_denoiser)
+        _st.current_x     = None
+        _st.current_sigma = None
+
+        _st.reinhard_en   = bool (v["reinhard_en"])
+        _st.reinhard_ref  = float(v["reinhard_ref"])
+        _st.rescale_en    = bool (v["rescale_en"])
+        _st.rescale_mult  = float(v["rescale_mult"])
+        _st.heuristic_en     = bool (v["heuristic_en"])
+        _st.heuristic_cfg    = float(v["heuristic_cfg"])
+        _st.heuristic_hstart = float(v["heuristic_hstart"])
+        _st.heuristic_sched_curve = v.get("heuristic_sched_curve", "Off")
+        _st.heuristic_sched_min   = float(v.get("heuristic_sched_min", 1.0))
+        _st.lir_en        = bool (v["lir_en"])
+        _st.lir_cfg       = float(v["lir_cfg"])
+        _st.lir_method    = v["lir_method"]
+        _st.lir_topk      = float(v["lir_topk"])
+        _st.mean_en       = bool (v["mean_en"])
+
+        # SEGA-inspired
+        _st.warmup_steps   = int  (v["warmup_steps"])
+        _st.end_step       = int  (v["end_step"])
+        _st.lock_after_end = bool (v["lock_after_end"])
+        _st.lock_triggered = False   # always reset at generation start
+        _st.apply_to_neg   = bool (v["apply_to_neg"])
+        _st.apply_to_pos   = bool (v["apply_to_pos"])
+
+        # Pass mode
+        _st.pass_mode  = v["pass_mode"]
+        _st.in_hr_pass = False          # first pass starts here
+
+        _st.hr_en  = bool (v["hr_en"])
+        _st.hr_cfg = float(v["hr_cfg"])
+
+        needs_hook = any([_st.nrs_en, _st.autocfg_en, _st.reinhard_en,
+                          _st.rescale_en, _st.heuristic_en, _st.lir_en,
+                          _st.mean_en, _st.tcfg_en,
+                          _st.interp_mode != "None"])
+        if needs_hook:
+            _hook_combine()
+
+        _st.enabled = True
+
+        gp = p.extra_generation_params
+        gp["CPF SkipEarlyCFG"]  = v["skip_early"]
+        gp["CPF NGMS"]          = v["ngms"]
+        if _st.ranges_en and _st.range_scales:
+            gp["CPF StepRanges"] = str([(s,e,va,i) for s,e,va,i in v["ranges"] if s or e])
+        if _st.sched_en and _st.sched_k != "off":
+            gp["CPF Schedule"] = f"{_SCHED.get(_st.sched_k)} ×{_st.sched_min:.2f}–×{_st.sched_max:.2f}"
+        if _st.boost_en:  gp["CPF Boost"]    = f"×{_st.boost_mul:.2f} from {_st.boost_from*100:.0f}%"
+        if _st.jitter_en: gp["CPF Jitter"]   = f"±{_st.jitter_amt*100:.0f}%"
+        if _st.autocfg_en: gp["CPF AutoCFG"] = f"{_st.autocfg_method} ref={_st.autocfg_ref}"
+        if _st.lerp_en:
+            gp["CPF LerpUncond"] = str(_st.lerp_str)
+            if _st.lerp_sched_curve != "Off":
+                gp["CPF LerpSched"] = f"{_st.lerp_sched_curve} min={_st.lerp_sched_min}"
+        if _st.skim_en:
+            gp["CPF Skim"] = f"{_st.skim_mode} s={_st.skim_scale}"
+            if _st.skim_sched_curve != "Off":
+                gp["CPF SkimSched"] = f"{_st.skim_sched_curve} min={_st.skim_sched_min}"
+        if _st.nrs_en:
+            gp["CPF NRS"] = f"skew={_st.nrs_skew} str={_st.nrs_stretch} sq={_st.nrs_squash}"
+            if _st.nrs_sched_curve != "Off":
+                gp["CPF NRSSched"] = f"{_st.nrs_sched_curve} minSkew={_st.nrs_sched_min_skew} minStr={_st.nrs_sched_min_stretch}"
+            if _st.nrs_sc_enabled:
+                gp["CPF NRSSC"] = ("R1:({}-{})sk={}st={} "
+                    "R2:({}-{})sk={}st={} lock={}".format(
+                    _st.nrs_sc_r1_start, _st.nrs_sc_r1_end,
+                    _st.nrs_sc_r1_skew, _st.nrs_sc_r1_stretch,
+                    _st.nrs_sc_r2_start, _st.nrs_sc_r2_end,
+                    _st.nrs_sc_r2_skew, _st.nrs_sc_r2_stretch,
+                    _st.nrs_sc_lock))
+        if _st.reinhard_en:  gp["CPF Reinhard"]  = str(_st.reinhard_ref)
+        if _st.rescale_en:   gp["CPF Rescale"]   = str(_st.rescale_mult)
+        if _st.heuristic_en:
+            gp["CPF Heuristic"] = str(_st.heuristic_cfg)
+            if _st.heuristic_hstart > 0: gp["CPF Heuristic Start"] = str(_st.heuristic_hstart)
+            if _st.heuristic_sched_curve != "Off":
+                gp["CPF HeuristicSched"] = f"{_st.heuristic_sched_curve} min={_st.heuristic_sched_min}"
+        if _st.lir_en:    gp["CPF LIR"]       = f"{_st.lir_method} cfg={_st.lir_cfg}"
+        if _st.mean_en:   gp["CPF SubtractMean"] = "1"
+        if _st.warmup_steps or _st.end_step:
+            gp["CPF Window"] = f"warmup={_st.warmup_steps} end={_st.end_step} lock={_st.lock_after_end}"
+        if _st.apply_to_pos or not _st.apply_to_neg:
+            gp["CPF Apply"] = f"pos={_st.apply_to_pos} neg={_st.apply_to_neg}"
+        if _st.pass_mode != "Both passes":
+            gp["CPF PassMode"] = _st.pass_mode
+
+    # ──────────────────────────────────────────────────────────────────────
+    def before_hr(self, p, *args):
+        # Arm HR-pass flag — persists lock_triggered from first pass (SEGA lock)
+        _st.in_hr_pass = True
+        # Reset inter-step state: HR pass is a new sequence
+        _st._prev_nrs   = None
+        _st._prev_vel   = None
+        _st._prev_delta = None
+        # NOTE: nrs_sc_locked is NOT reset here — Lock after End persists across HR
+        # pass, matching NRS behaviour. It is reset only in postprocess.
+
+        # HR CFG override (independent of pass_mode)
+        if _st.enabled and _st.hr_en and isinstance(p, StableDiffusionProcessingTxt2Img):
+            _st.hr_cfg_saved = p.cfg_scale
+            p.cfg_scale      = _st.hr_cfg
+            p.extra_generation_params["CPF HR_CFG"] = _st.hr_cfg
+
+    def postprocess_image(self, p, pp, *args):
+        # NOTE: intentionally NOT restoring hr_cfg_saved here.
+        # postprocess_image is called for every image in a batch, so restoring
+        # after the first image would leave the rest using base cfg instead of
+        # hr_cfg.  The restore is done once in postprocess() after all images.
+        pass
+
+    def postprocess(self, p, processed, *args):
+        _st.enabled        = False
+        _st.lock_triggered = False
+        _st.nrs_sc_locked  = False
+        _st.in_hr_pass     = False
+        # Reset inter-step state
+        _st._prev_nrs   = None
+        _st._prev_vel   = None
+        _st._prev_delta = None
+        # Reset context
+        _st.current_x     = None
+        _st.current_sigma = None
+        _unhook_combine()
+        if _st.hr_cfg_saved is not None:
+            p.cfg_scale      = _st.hr_cfg_saved
+            _st.hr_cfg_saved = None