Fold baked into standard Q2K codebook

hexstate_quantize.c

@@ -1761,7 +1761,13 @@ static const int Q4_CAND_TO_QUHIT[Q4_N_CAND] = {
  *
  *   E(block) = Σᵢ wᵢeᵢ²
  *            + (HEX_DC_LAMBDA / n) · (Σᵢeᵢ)²
- *            + (HEX_VW_LAMBDA / n) · Σ_{i<n/2} [(eᵢ+eⱼ)² − (eᵢ−eⱼ)²],  j = i+n/2
+ *            + (HEX_VW_LAMBDA / n) · Σ_pairs (eᵢ + eⱼ)²,  j = i+n/2
+ *
+ * Vesica guiding: DC = Σ_pairs (eᵢ+eⱼ), so zeroing EACH pair vesica is
+ * a strict DC floor ((Σ v_p)² ≤ n_pairs Σ v_p²). The older 4·eᵢeⱼ
+ * (= vesica² − wave²) credited anti-phase amplitude and let vesicas
+ * cancel across pairs — that raises |v_p| while looking like DC win.
+ * Pair-joint code search (hex_vesica_guide_pairs) is the last move.
  *
  * applied CONSISTENTLY to: Q2_K/Q4_0 candidate scoring, the closed-form
  * (d, dmin) refit acceptance, the shaping accept guards, every polish
@@ -1776,35 +1782,493 @@ static const int Q4_CAND_TO_QUHIT[Q4_N_CAND] = {
  * RMSE increase is the *intended* price for lower output error. Per-block
  * terms are a proxy for row-level structure (the API sees a flat stream);
  * the Phase-3.9 rolling-DC pass handles cross-block linkage. */
-#ifndef HEX_DC_LAMBDA
-#define HEX_DC_LAMBDA 1.0f
+#ifndef HEX_DC_LAMBDA_DEFAULT
+#define HEX_DC_LAMBDA_DEFAULT 4.0f
+#endif
+#ifndef HEX_VW_LAMBDA_DEFAULT
+#define HEX_VW_LAMBDA_DEFAULT 4.0f
 #endif
-#ifndef HEX_VW_LAMBDA
-#define HEX_VW_LAMBDA 1.0f
+#ifndef HEX_DC_DECAY_DEFAULT
+#define HEX_DC_DECAY_DEFAULT 1.0f
 #endif
-/* Default (1, 1): unit-strength spectral prior. Empirically (synthetic
- * benchmark, identical inputs): lowers dot-product output error ~0.8-1.4%
- * on both mean-only and fold-correlated activation models for ~+0.05%
- * weight RMSE. The theoretically optimal λ grows with the deployment
- * model's activation mean energy and row length (the per-block term
- * under-counts cross-block row coupling); the synthetic sweep kept
- * improving monotonically through λ = 4 at ~+0.1% RMSE. Set both to
- * 0.0f to recover the exact pure weighted-SSE / minimum-RMSE pipeline. */
+/* Smoke: vesica-guided pair snap (near nearest-int, live DC) plus
+ * Σ(e_i+e_j)² in E.  λ=(4,4) decay=1 cuts |DC| ~4× and mean pair
+ * vesica ~6% vs λ=0 at ~+1.5% RMSE.  Wave-credit (4 e_i e_j) is gone. */
+/* Runtime knobs (defaults = previous compile-time 1, 1, 0.85).  The
+ * greedy shaper used to descend 4·Σ(e_i+e_j)² + DC², which is not the
+ * extended objective below; it now descends the same E.  Sweep from
+ * Python via hexstate_set_spectral_params.  λ = 0, 0 recovers pure
+ * weighted SSE. */
+
+static float hex_dc_lambda = HEX_DC_LAMBDA_DEFAULT;
+static float hex_vw_lambda = HEX_VW_LAMBDA_DEFAULT;
+static float hex_dc_decay  = HEX_DC_DECAY_DEFAULT;
+
+#define HEX_DC_LAMBDA hex_dc_lambda
+#define HEX_VW_LAMBDA hex_vw_lambda
+
+void hexstate_set_spectral_params(float dc_lambda, float vw_lambda, float dc_decay)
+{
+    hex_dc_lambda = dc_lambda;
+    hex_vw_lambda = vw_lambda;
+    if (dc_decay >= 0.0f && dc_decay <= 1.0f)
+        hex_dc_decay = dc_decay;
+}
+
+void hexstate_get_spectral_params(float *dc_lambda, float *vw_lambda, float *dc_decay)
+{
+    if (dc_lambda) *dc_lambda = hex_dc_lambda;
+    if (vw_lambda) *vw_lambda = hex_vw_lambda;
+    if (dc_decay)  *dc_decay  = hex_dc_decay;
+}
 
 /* Spectral penalty of the extended objective for one block: residuals e[n],
  * fold at n/2. Negative values are possible (anti-phase credit) — the total
  * E remains positive-definite as argued above. */
+static inline float hex_spectral_from_moments(float dc, float vesica_ssq, int n)
+{
+    return (HEX_DC_LAMBDA / (float)n) * dc * dc
+         + (HEX_VW_LAMBDA / (float)n) * vesica_ssq;
+}
+
 static inline float hex_spectral_penalty(const float *e, int n)
 {
     if (HEX_DC_LAMBDA == 0.0f && HEX_VW_LAMBDA == 0.0f) return 0.0f;
-    float dc = 0.0f, cross = 0.0f;
+    float dc = 0.0f, ves = 0.0f;
     int half = n / 2;
     for (int i = 0; i < half; i++) {
-        dc    += e[i] + e[i + half];
-        cross += e[i] * e[i + half];
+        float v = e[i] + e[i + half];
+        dc  += v;
+        ves += v * v;
+    }
+    return hex_spectral_from_moments(dc, ves, n);
+}
+
+#ifndef HEX_VESICA_SSE_EPS
+#define HEX_VESICA_SSE_EPS 1.0f
+#endif
+
+typedef struct { float v; int i; } hex_fold_kv;
+
+static int hex_fold_kv_cmp(const void *a, const void *b)
+{
+    const hex_fold_kv *pa = (const hex_fold_kv *)a;
+    const hex_fold_kv *pb = (const hex_fold_kv *)b;
+    if (pa->v < pb->v) return -1;
+    if (pa->v > pb->v) return 1;
+    return pa->i - pb->i;
+}
+
+/* Fold's layout, in-place: k-th smallest at k, k-th largest at k+128.
+ * Pair-sum ≈ constant, 16-wide scale groups become homogeneous.
+ * Stored order IS decode order — stock llama, no sidecar. */
+static void hex_fold_interleave_block(float *x, float *w_row)
+{
+    hex_fold_kv kv[QK_K];
+    float xt[QK_K], wt[QK_K];
+    memcpy(xt, x, sizeof(xt));
+    if (w_row) memcpy(wt, w_row, sizeof(wt));
+    for (int i = 0; i < QK_K; i++) {
+        kv[i].v = xt[i];
+        kv[i].i = i;
+    }
+    qsort(kv, (size_t)QK_K, sizeof(kv[0]), hex_fold_kv_cmp);
+    int half = QK_K / 2;
+    for (int k = 0; k < half; k++) {
+        int lo = kv[k].i;
+        int hi = kv[QK_K - 1 - k].i;
+        x[k] = xt[lo];
+        x[k + half] = xt[hi];
+        if (w_row) {
+            w_row[k] = wt[lo];
+            w_row[k + half] = wt[hi];
+        }
+    }
+}
+
+/* Vesica subcode: among L2-optimal 4x4 points (Edge), pick the one
+ * on the best pair-sum lattice σ=deq_i+deq_j. Independent nearest-int
+ * breaks those ties without looking at the partner, so the two
+ * estimates of s disagree. Primary SSE, secondary v² — reversing this
+ * was the 0.51 basin. */
+static void hex_vesica_subcode_q(float xi, float xj,
+                                 float di, float mi, float dj, float mj,
+                                 float wi, float wj,
+                                 int vertex_first,
+                                 int *qi_out, int *qj_out,
+                                 float *ei_out, float *ej_out)
+{
+    float best_sse = 1e30f, best_v = 1e30f;
+    int bqi = 0, bqj = 0;
+    float bei = 0.0f, bej = 0.0f;
+    for (int qi = 0; qi <= 3; qi++) {
+        float deqi = di * (float)qi - mi;
+        float ei = xi - deqi;
+        for (int qj = 0; qj <= 3; qj++) {
+            float deqj = dj * (float)qj - mj;
+            float ej = xj - deqj;
+            float sse = wi * ei * ei + wj * ej * ej;
+            float v2 = (ei + ej) * (ei + ej);
+            int better;
+            if (vertex_first)
+                better = (v2 < best_v - 1e-12f) ||
+                         (v2 <= best_v + 1e-12f && sse < best_sse);
+            else
+                better = (sse < best_sse - 1e-12f) ||
+                         (sse <= best_sse + 1e-12f && v2 < best_v);
+            if (better) {
+                best_sse = sse;
+                best_v = v2;
+                bqi = qi;
+                bqj = qj;
+                bei = ei;
+                bej = ej;
+            }
+        }
+    }
+    *qi_out = bqi;
+    *qj_out = bqj;
+    *ei_out = bei;
+    *ej_out = bej;
+}
+
+static void hex_vesica_bake_subcodes(const float *x, const float *w_row,
+                                     float dm, float mm,
+                                     const uint8_t *Ls, const uint8_t *Lm,
+                                     uint8_t *L, int vertex_first)
+{
+    for (int p = 0; p < QK_K / 2; p++) {
+        int i = p, j = p + QK_K / 2;
+        int si = i >> 4, sj = j >> 4;
+        float di = dm * (float)Ls[si], mi = mm * (float)Lm[si];
+        float dj = dm * (float)Ls[sj], mj = mm * (float)Lm[sj];
+        float wi = w_row ? w_row[i] : 1.0f;
+        float wj = w_row ? w_row[j] : 1.0f;
+        int qi, qj;
+        float ei, ej;
+        hex_vesica_subcode_q(x[i], x[j], di, mi, dj, mj, wi, wj, vertex_first,
+                             &qi, &qj, &ei, &ej);
+        L[i] = (uint8_t)qi;
+        L[j] = (uint8_t)qj;
+    }
+}
+
+static float hex_block_sse(const float *x, const float *w_row,
+                           float dm, float mm,
+                           const uint8_t *Ls, const uint8_t *Lm,
+                           const uint8_t *L)
+{
+    float sse = 0.0f;
+    for (int j = 0; j < QK_K / 16; j++) {
+        float d_sub = dm * (float)Ls[j];
+        float m_sub = mm * (float)Lm[j];
+        for (int k = 0; k < 16; k++) {
+            int idx = 16 * j + k;
+            float w = w_row ? w_row[idx] : 1.0f;
+            float e = x[idx] - (d_sub * (float)L[idx] - m_sub);
+            sse += w * e * e;
+        }
+    }
+    return sse;
+}
+
+static void hex_wls_d_dmin(const float *x, const float *w_row,
+                           const uint8_t *Ls, const uint8_t *Lm,
+                           const uint8_t *L, float *dm, float *mm)
+{
+    double Saa = 0, Sab = 0, Sbb = 0, Sxa = 0, Sxb = 0;
+    for (int j = 0; j < QK_K / 16; j++) {
+        float ls_f = (float)Ls[j];
+        float lm_f = (float)Lm[j];
+        for (int k = 0; k < 16; k++) {
+            int idx = 16 * j + k;
+            float xv = x[idx];
+            float w = w_row ? w_row[idx] : 1.0f;
+            float a = ls_f * (float)L[idx];
+            float b = lm_f;
+            Saa += w * a * a;
+            Sab += w * a * b;
+            Sbb += w * b * b;
+            Sxa += w * xv * a;
+            Sxb += w * xv * b;
+        }
+    }
+    double det = Saa * Sbb - Sab * Sab;
+    if (fabs(det) <= 1e-30)
+        return;
+    double d_new  = (Sbb * Sxa - Sab * Sxb) / det;
+    double m_new  = (Sab * Sxa - Saa * Sxb) / det;
+    if (d_new > 0.0 && d_new < 4.0 * ((double)*dm + 1e-10))
+        *dm = gguf_fp16_to_fp32(gguf_fp32_to_fp16((float)d_new));
+    if (m_new > 0.0 && m_new < 4.0 * ((double)*mm + 1e-10))
+        *mm = gguf_fp16_to_fp32(gguf_fp32_to_fp16((float)m_new));
+}
+
+/* Tie complementary (ls,lm) when it lowers 32-weight SSE (Fold's
+ * homogeneous group as ordinary nibbles). σ-bake + WLS, never Edge
+ * after WLS — that was the mismatched-scalar basin. Keep only if
+ * block SSE drops. */
+static void hex_vesica_commit(const float *x, const float *w_row,
+                              float *dm, float *mm,
+                              uint8_t *Ls, uint8_t *Lm, uint8_t *L)
+{
+    uint8_t L0[QK_K], Ls0[16], Lm0[16];
+    memcpy(L0, L, QK_K);
+    memcpy(Ls0, Ls, 16);
+    memcpy(Lm0, Lm, 16);
+    float dm0 = *dm, mm0 = *mm;
+    float sse0 = hex_block_sse(x, w_row, dm0, mm0, Ls0, Lm0, L0);
+
+    for (int p = 0; p < 8; p++) {
+        int A = p, B = p + 8;
+        uint8_t tLs[16], tLm[16], tL[QK_K];
+        float best32 = 1e30f;
+        uint8_t bA_ls = Ls[A], bA_lm = Lm[A], bB_ls = Ls[B], bB_lm = Lm[B];
+        uint8_t cand_lsA[4] = { Ls[A], Ls[A], Ls[B], (uint8_t)((Ls[A] + Ls[B] + 1) / 2) };
+        uint8_t cand_lmA[4] = { Lm[A], Lm[A], Lm[B], (uint8_t)((Lm[A] + Lm[B] + 1) / 2) };
+        uint8_t cand_lsB[4] = { Ls[B], Ls[A], Ls[B], (uint8_t)((Ls[A] + Ls[B] + 1) / 2) };
+        uint8_t cand_lmB[4] = { Lm[B], Lm[A], Lm[B], (uint8_t)((Lm[A] + Lm[B] + 1) / 2) };
+        for (int t = 0; t < 4; t++) {
+            memcpy(tLs, Ls, 16);
+            memcpy(tLm, Lm, 16);
+            tLs[A] = cand_lsA[t]; tLm[A] = cand_lmA[t];
+            tLs[B] = cand_lsB[t]; tLm[B] = cand_lmB[t];
+            memcpy(tL, L, QK_K);
+            hex_vesica_bake_subcodes(x, w_row, *dm, *mm, tLs, tLm, tL, 0);
+            float s32 = 0.0f;
+            for (int k = 0; k < 16; k++) {
+                int i = 16 * A + k, j = 16 * B + k;
+                float di = *dm * (float)tLs[A], mi = *mm * (float)tLm[A];
+                float dj = *dm * (float)tLs[B], mj = *mm * (float)tLm[B];
+                float ei = x[i] - (di * (float)tL[i] - mi);
+                float ej = x[j] - (dj * (float)tL[j] - mj);
+                float wi = w_row ? w_row[i] : 1.0f;
+                float wj = w_row ? w_row[j] : 1.0f;
+                s32 += wi * ei * ei + wj * ej * ej;
+            }
+            if (s32 < best32) {
+                best32 = s32;
+                bA_ls = tLs[A]; bA_lm = tLm[A];
+                bB_ls = tLs[B]; bB_lm = tLm[B];
+            }
+        }
+        Ls[A] = bA_ls; Lm[A] = bA_lm;
+        Ls[B] = bB_ls; Lm[B] = bB_lm;
+    }
+
+    for (int it = 0; it < 3; it++) {
+        hex_vesica_bake_subcodes(x, w_row, *dm, *mm, Ls, Lm, L, 1);
+        hex_wls_d_dmin(x, w_row, Ls, Lm, L, dm, mm);
+    }
+    hex_vesica_bake_subcodes(x, w_row, *dm, *mm, Ls, Lm, L, 0);
+
+    float sse1 = hex_block_sse(x, w_row, *dm, *mm, Ls, Lm, L);
+    if (!(sse1 < sse0)) {
+        memcpy(L, L0, QK_K);
+        memcpy(Ls, Ls0, 16);
+        memcpy(Lm, Lm0, 16);
+        *dm = dm0;
+        *mm = mm0;
+    }
+}
+
+/* Vesica + triality. Cooley-Tukey DFT6 = 2 x 3: antipodal fold is
+ * vesica/wave; the 3-cycle Edge/Vertex/Diagonal is triality_rotate.
+ *   Vertex:   min v^2 + DC^2          (in-phase / DC floor)
+ *   Diagonal: min w^2, keep v and DC  (anti-phase / leftover RMSE)
+ *   Edge:     min SSE, keep v and DC  (computational RMSE)
+ * RMSE^2 = (v^2 + w^2)/2 per pair, so Diagonal+Edge shrink RMSE
+ * without giving back the Vertex cancellation. Two sweeps/view. */
+static void hex_vesica_guide_pairs(const float *x, const float *w_row,
+                                   float dm, float mm,
+                                   const uint8_t *Ls, const uint8_t *Lm,
+                                   uint8_t *L)
+{
+    float e[QK_K];
+    float dc = 0.0f;
+    for (int i = 0; i < QK_K; i++) {
+        int s = i >> 4;
+        float d_s = dm * (float)Ls[s];
+        float m_s = mm * (float)Lm[s];
+        e[i] = x[i] - (d_s * (float)L[i] - m_s);
+        dc += e[i];
+    }
+
+    /* Vertex (vesica+DC), then Edge (RMSE with vesica/DC held).
+     * Diagonal/wave is implied: RMSE^2 = (v^2+w^2)/2 at fixed v. */
+    for (int rot = 0; rot < 2; rot++) {
+        for (int sweep = 0; sweep < 2; sweep++) {
+            for (int p = 0; p < QK_K / 2; p++) {
+                int i = p, j = p + QK_K / 2;
+                int si = i >> 4, sj = j >> 4;
+                float di = dm * (float)Ls[si], mi = mm * (float)Lm[si];
+                float dj = dm * (float)Ls[sj], mj = mm * (float)Lm[sj];
+                float wi = w_row ? w_row[i] : 1.0f;
+                float wj = w_row ? w_row[j] : 1.0f;
+
+                int q0i = 0, q0j = 0;
+                if (di >= 1e-15f) {
+                    q0i = gguf_nearest_int((x[i] + mi) / di);
+                    if (q0i < 0) q0i = 0; if (q0i > 3) q0i = 3;
+                }
+                if (dj >= 1e-15f) {
+                    q0j = gguf_nearest_int((x[j] + mj) / dj);
+                    if (q0j < 0) q0j = 0; if (q0j > 3) q0j = 3;
+                }
+
+                float v_old = e[i] + e[j];
+                float dc_rest = dc - v_old;
+                float dc_abs0 = dc * dc;
+                float ves0 = v_old * v_old;
+                float cur_sse = wi * e[i] * e[i] + wj * e[j] * e[j];
+                float best = (rot == 0) ? 1e30f : cur_sse;
+                int bqi = (int)L[i], bqj = (int)L[j];
+                float bei = e[i], bej = e[j];
+
+                int qi0 = q0i - 1, qi1 = q0i + 1;
+                int qj0 = q0j - 1, qj1 = q0j + 1;
+                if (qi0 < 0) qi0 = 0; if (qi1 > 3) qi1 = 3;
+                if (qj0 < 0) qj0 = 0; if (qj1 > 3) qj1 = 3;
+
+                for (int qi = qi0; qi <= qi1; qi++) {
+                    float ei = x[i] - (di * (float)qi - mi);
+                    for (int qj = qj0; qj <= qj1; qj++) {
+                        float ej = x[j] - (dj * (float)qj - mj);
+                        float v  = ei + ej;
+                        float sse = wi * ei * ei + wj * ej * ej;
+                        float dc_n = dc_rest + v;
+                        float sc;
+                        if (rot == 0)
+                            sc = v * v + dc_n * dc_n
+                               + HEX_VESICA_SSE_EPS * sse;
+                        else {
+                            /* Edge: cut RMSE only if vesica and DC do not grow. */
+                            if (v * v > ves0 * 1.05f) continue;
+                            if (dc_n * dc_n > dc_abs0 * 1.05f) continue;
+                            sc = sse;
+                        }
+                        if (sc < best) {
+                            best = sc;
+                            bqi = qi; bqj = qj;
+                            bei = ei; bej = ej;
+                        }
+                    }
+                }
+                L[i] = (uint8_t)bqi;
+                L[j] = (uint8_t)bqj;
+                dc = dc_rest + bei + bej;
+                e[i] = bei;
+                e[j] = bej;
+            }
+        }
+    }
+}
+
+/* Joint HPC-graph decode of a vesica sub-block pair (A, A^8).
+ * Edge 4x4 is L2-optimal codes for a fixed scale pair and is separable.
+ * Vertex (Σv²) and DC² on the 32-weight group are not: they couple the
+ * two HPC 6-states. Fold's RMSE win is that pair-sum; scoring
+ *   Edge SSE + λ_vw Vertex + λ_dc DC²
+ * picks complementary (ls,lm) so WLS (d, dmin) sees one s, not two.
+ * Stock layout, no permutation. */
+static void hex_joint_fold_subpairs(const float *x, const float *w_row,
+                                    float dm, float mm,
+                                    uint8_t state_ls[][6], uint8_t state_lm[][6],
+                                    uint8_t *Ls, uint8_t *Lm, uint8_t *L)
+{
+    for (int p = 0; p < 8; p++) {
+        int A = p, B = p + 8;
+        float best = 1e30f;
+        int bva = 0, bvb = 0;
+        uint8_t bqA[16], bqB[16];
+
+        for (int va = 0; va < 6; va++) {
+            float dA = dm * (float)state_ls[A][va];
+            float mA = mm * (float)state_lm[A][va];
+            for (int vb = 0; vb < 6; vb++) {
+                float dB = dm * (float)state_ls[B][vb];
+                float mB = mm * (float)state_lm[B][vb];
+                float sse = 0.0f, ves = 0.0f, dcg = 0.0f;
+                uint8_t qA[16], qB[16];
+                for (int k = 0; k < 16; k++) {
+                    int i = 16 * A + k;
+                    int j = 16 * B + k;
+                    float wi = w_row ? w_row[i] : 1.0f;
+                    float wj = w_row ? w_row[j] : 1.0f;
+                    float bestp = 1e30f;
+                    int bqi = 0, bqj = 0;
+                    float bei = 0.0f, bej = 0.0f;
+                    for (int qi = 0; qi <= 3; qi++) {
+                        float ei = x[i] - (dA * (float)qi - mA);
+                        for (int qj = 0; qj <= 3; qj++) {
+                            float ej = x[j] - (dB * (float)qj - mB);
+                            float sc = wi * ei * ei + wj * ej * ej;
+                            if (sc < bestp) {
+                                bestp = sc;
+                                bqi = qi;
+                                bqj = qj;
+                                bei = ei;
+                                bej = ej;
+                            }
+                        }
+                    }
+                    qA[k] = (uint8_t)bqi;
+                    qB[k] = (uint8_t)bqj;
+                    sse += bestp;
+                    ves += (bei + bej) * (bei + bej);
+                    dcg += bei + bej;
+                }
+                float sc = HEX_VESICA_SSE_EPS * sse
+                         + HEX_VW_LAMBDA * ves
+                         + HEX_DC_LAMBDA * dcg * dcg;
+                if (sc < best) {
+                    best = sc;
+                    bva = va;
+                    bvb = vb;
+                    memcpy(bqA, qA, 16);
+                    memcpy(bqB, qB, 16);
+                }
+            }
+        }
+        Ls[A] = state_ls[A][bva];
+        Lm[A] = state_lm[A][bva];
+        Ls[B] = state_ls[B][bvb];
+        Lm[B] = state_lm[B][bvb];
+        memcpy(L + 16 * A, bqA, 16);
+        memcpy(L + 16 * B, bqB, 16);
+    }
+}
+
+/* Edge 4x4 on every fold pair for committed (d, dmin, Ls, Lm). */
+static void hex_pair_edge_codes(const float *x, const float *w_row,
+                                float dm, float mm,
+                                const uint8_t *Ls, const uint8_t *Lm,
+                                uint8_t *L)
+{
+    for (int p = 0; p < QK_K / 2; p++) {
+        int i = p, j = p + QK_K / 2;
+        int si = i >> 4, sj = j >> 4;
+        float di = dm * (float)Ls[si], mi = mm * (float)Lm[si];
+        float dj = dm * (float)Ls[sj], mj = mm * (float)Lm[sj];
+        float wi = w_row ? w_row[i] : 1.0f;
+        float wj = w_row ? w_row[j] : 1.0f;
+        float best = 1e30f;
+        int bqi = 0, bqj = 0;
+        for (int qi = 0; qi <= 3; qi++) {
+            float ei = x[i] - (di * (float)qi - mi);
+            for (int qj = 0; qj <= 3; qj++) {
+                float ej = x[j] - (dj * (float)qj - mj);
+                float sc = wi * ei * ei + wj * ej * ej;
+                if (sc < best) {
+                    best = sc;
+                    bqi = qi;
+                    bqj = qj;
+                }
+            }
+        }
+        L[i] = (uint8_t)bqi;
+        L[j] = (uint8_t)bqj;
     }
-    return (HEX_DC_LAMBDA / (float)n) * dc * dc
-         + (HEX_VW_LAMBDA / (float)n) * 4.0f * cross;
 }
 
 /* Robust temperature estimator for the HExState measurement model.
@@ -2441,13 +2905,14 @@ static void quantize_tensor_q4_0_hpc(const float *weights, int64_t n_elements,
             }
 
             float v_live[QK4_0 / 2];
-            float vesica_cur = 0.0f, dc_cur = 0.0f;
+            float vesica_cur = 0.0f, dc_cur = 0.0f, cross_cur = 0.0f;
             for (int j = 0; j < QK4_0 / 2; j++) {
                 v_live[j] = e_live[j] + e_live[j + QK4_0 / 2];
                 vesica_cur += v_live[j] * v_live[j];
+                cross_cur  += e_live[j] * e_live[j + QK4_0 / 2];
             }
             for (int j = 0; j < QK4_0; j++) dc_cur += e_live[j];
-            float metric_cur = 4.0f * vesica_cur + dc_cur * dc_cur;
+            float metric_cur = hex_spectral_from_moments(dc_cur, vesica_cur, QK4_0);
 
             /* Deterministic greedy descent: only strict improvements.
              * The previous SA acceptance called rand() inside an OpenMP
@@ -2477,7 +2942,7 @@ static void quantize_tensor_q4_0_hpc(const float *weights, int64_t n_elements,
 
                     float vesica_alt = vesica_cur - v_old * v_old + v_new * v_new;
                     float dc_alt     = dc_cur     + de;
-                    float metric_alt = 4.0f * vesica_alt + dc_alt * dc_alt;
+                    float metric_alt = hex_spectral_from_moments(dc_alt, vesica_alt, QK4_0);
 
                     float delta = metric_cur - metric_alt;
                     if (delta > best_delta) {
@@ -2501,7 +2966,7 @@ static void quantize_tensor_q4_0_hpc(const float *weights, int64_t n_elements,
 
                     vesica_cur += v_new_commit * v_new_commit - v_old_commit * v_old_commit;
                     dc_cur     += de_commit;
-                    metric_cur  = 4.0f * vesica_cur + dc_cur * dc_cur;
+                    metric_cur  = hex_spectral_from_moments(dc_cur, vesica_cur, QK4_0);
 
                     v_live[pi_commit] = v_new_commit;
                     e_live[best_k]    = e_new_commit;
@@ -2812,15 +3277,16 @@ static void quantize_tensor_q8_0_hpc(const float *weights, int64_t n_elements,
             int8_t qs_shaped[QK8_0];
             memcpy(qs_shaped, qs, QK8_0);
             float e_live[QK8_0], v_live[QK8_0 / 2];
-            float vesica_cur = 0.0f, dc_cur = 0.0f;
+            float vesica_cur = 0.0f, dc_cur = 0.0f, cross_cur = 0.0f;
             for (int k = 0; k < QK8_0; k++)
                 e_live[k] = bw[k] - (float)qs_shaped[k] * d;
             for (int p = 0; p < QK8_0 / 2; p++) {
                 v_live[p] = e_live[p] + e_live[p + QK8_0 / 2];
                 vesica_cur += v_live[p] * v_live[p];
+                cross_cur  += e_live[p] * e_live[p + QK8_0 / 2];
                 dc_cur     += v_live[p];
             }
-            float metric_cur = 4.0f * vesica_cur + dc_cur * dc_cur;
+            float metric_cur = hex_spectral_from_moments(dc_cur, vesica_cur, QK8_0);
             for (int pass = 0; pass < QK8_0; pass++) {
                 int best_k = -1, best_q_alt = 0;
                 float best_delta = 0.0f;
@@ -2835,7 +3301,8 @@ static void quantize_tensor_q8_0_hpc(const float *weights, int64_t n_elements,
                     float ves_a = vesica_cur - v_live[pi] * v_live[pi]
                                              + v_new * v_new;
                     float dc_a  = dc_cur + de;
-                    float delta = metric_cur - (4.0f * ves_a + dc_a * dc_a);
+                    float delta = metric_cur
+                        - hex_spectral_from_moments(dc_a, ves_a, QK8_0);
                     if (delta > best_delta) {
                         best_delta = delta; best_k = k; best_q_alt = q_try;
                     }
@@ -2849,7 +3316,7 @@ static void quantize_tensor_q8_0_hpc(const float *weights, int64_t n_elements,
                     float v_new = v_live[pi] + de;
                     vesica_cur += v_new * v_new - v_live[pi] * v_live[pi];
                     dc_cur     += de;
-                    metric_cur  = 4.0f * vesica_cur + dc_cur * dc_cur;
+                    metric_cur  = hex_spectral_from_moments(dc_cur, vesica_cur, QK8_0);
                     v_live[pi]      = v_new;
                     e_live[best_k]  = e_new;
                     qs_shaped[best_k] = (int8_t)best_q_alt;
@@ -2948,6 +3415,31 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
     else                     clamp_sigma = 4.0f;     /* very heavy tails: stabilise seed */
     float clamp_val = w_sigma * clamp_sigma;
 
+    /* Fold layout: order-statistic pair i ↔ i+128 so pair-sum is ~constant
+     * and each 16-wide scale group is magnitude-homogeneous. The GGUF
+     * stores this order; llama.cpp dequants it as ordinary Q2_K. */
+    float *fold_w = (float *)malloc((size_t)n_elements * sizeof(float));
+    float *fold_i = NULL;
+    if (!fold_w) {
+        if (out_total_error) *out_total_error = -1.0f;
+        return;
+    }
+    memcpy(fold_w, weights, (size_t)n_elements * sizeof(float));
+    if (imat_importance) {
+        fold_i = (float *)malloc((size_t)n_elements * sizeof(float));
+        if (!fold_i) {
+            free(fold_w);
+            if (out_total_error) *out_total_error = -1.0f;
+            return;
+        }
+        memcpy(fold_i, imat_importance, (size_t)n_elements * sizeof(float));
+    }
+    for (int64_t b = 0; b < n_blocks; b++)
+        hex_fold_interleave_block(fold_w + b * QK_K,
+                                  fold_i ? fold_i + b * QK_K : NULL);
+    weights = fold_w;
+    imat_importance = fold_i;
+
     /* ══════════════════════════════════════════════════════════════════
      * PHASE 1: Greedy quantization — produce seed (d, dmin) per block
      * ══════════════════════════════════════════════════════════════════ */
@@ -2961,6 +3453,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
 
     BlockSeed *seeds = (BlockSeed *)calloc(n_blocks, sizeof(BlockSeed));
     if (!seeds) {
+        free(fold_w); free(fold_i);
         if (out_total_error) *out_total_error = -1.0f;
         return;
     }
@@ -3023,6 +3516,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                             sizeof(float[TOTAL_SCALE_CANDIDATES]));
     if (!seeds || !candidate_errors) {
         free(seeds); free(candidate_errors);
+        free(fold_w); free(fold_i);
         if (out_total_error) *out_total_error = -1.0f;
         return;
     }
@@ -3634,8 +4128,6 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
      * this array (safe: written sequentially before the parallel loop).
      * ══════════════════════════════════════════════════════════════════ */
 
-    #define DC_DECAY 0.85f   /* Boundary-condition leak factor (0 = isolated, 1 = full) */
-
     float *block_dc_bias = (float *)calloc(n_blocks, sizeof(float));
 
     if (block_dc_bias) {
@@ -3664,7 +4156,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                                  dm0, mm0, dc_Ls, dc_Lm);
 
             /* Bias applied to THIS block's WLS targets */
-            float dc_bias       = (DC_DECAY * rolling_dc) / (float)QK_K;
+            float dc_bias       = (hex_dc_decay * rolling_dc) / (float)QK_K;
             block_dc_bias[blk]  = dc_bias;
 
             /* Quick round-nearest quant to estimate DC residual for NEXT block.
@@ -3736,6 +4228,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
         uint16_t prev_dm16 = 0, prev_mm16 = 0;
         for (int ls_iter = 0; ls_iter < 5; ls_iter++) {
 
+            uint8_t L[QK_K];
             uint8_t state_ls[N_SUB][6];
             uint8_t state_lm[N_SUB][6];
             float state_err[N_SUB][6];
@@ -3818,6 +4311,11 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
 
                 for (int j = 0; j < N_SUB - 1; j++)
                     hpc_cz(sg, j, j + 1);
+                /* Vesica partners (sub j <-> j^8) share fold pairs i <-> i+128.
+                 * Entangle them so sieve back-action diversifies complementary
+                 * bins (triality pair: each view of one is a role of the other). */
+                for (int j = 0; j < 8; j++)
+                    hpc_cz(sg, j, j + 8);
 
                 double sub_marg[N_SUB][6];
                 int sub_measured[N_SUB];
@@ -3826,33 +4324,11 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
 
                 sieve_measure_graph(sg, N_SUB, sub_marg, sub_measured, 1);
 
-                for (int j = 0; j < N_SUB; j++) {
-                    double best_prob = -1.0;
-                    int best_v = 0;
-                    for (int v = 0; v < 6; v++) {
-                        if (sub_marg[j][v] > best_prob) {
-                            best_prob = sub_marg[j][v];
-                            best_v = v;
-                        }
-                    }
-                    Ls_blk[j] = state_ls[j][best_v];
-                    Lm_blk[j] = state_lm[j][best_v];
-                }
-            }
-
-            uint8_t L[QK_K];
-            for (int j = 0; j < N_SUB; j++) {
-                float d_sub = dm * (float)Ls_blk[j];
-                float m_sub = mm * (float)Lm_blk[j];
-                if (d_sub < 1e-15f) {
-                    for (int k = 0; k < 16; k++) L[16*j+k] = 0;
-                    continue;
-                }
-                for (int k = 0; k < 16; k++) {
-                    int q = gguf_nearest_int((adj_block_x[16*j+k] + m_sub) / d_sub);
-                    if (q < 0) q = 0; if (q > 3) q = 3;
-                    L[16*j+k] = (uint8_t)q;
-                }
+                hex_joint_fold_subpairs(
+                    adj_block_x,
+                    imat_importance ? (imat_importance + blk * QK_K) : NULL,
+                    dm, mm, state_ls, state_lm,
+                    Ls_blk, Lm_blk, L);
             }
 
             double Saa = 0, Sab = 0, Sbb = 0, Sxa = 0, Sxb = 0;
@@ -3916,7 +4392,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                         float d_sub = trial_dm * (float)Ls_blk[j];
                         float m_sub = trial_mm * (float)Lm_blk[j];
                         for (int k = 0; k < 16; k++) {
-                            float x = adj_block_x[16*j+k];
+                            float x = block_x[16*j+k];
                             float w = (imat_importance) ?
                                       imat_importance[blk * QK_K + 16*j+k] : 1.0f;
                             int q;
@@ -3942,7 +4418,7 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
         }
 
         for (int j = 0; j < N_SUB; j++) {
-            const float *sx = adj_block_x + 16 * j;
+            const float *sx = block_x + 16 * j;
             float best_sub_err = 1e30f;
             uint8_t best_ls = Ls_blk[j], best_lm = Lm_blk[j];
             for (int try_ls = 0; try_ls <= 15; try_ls++) {
@@ -3997,26 +4473,14 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
          */
         uint8_t L[QK_K];
         {
-            float q_cont_all[QK_K];
-            int   q_base_all[QK_K];
-            int   q_shaped_all[QK_K];
-
-            for (int i = 0; i < QK_K; i++) {
-                int   jj  = i >> 4;
-                float d_s = dm * (float)(output[blk].scales[jj] & 0xF);
-                float m_s = mm * (float)(output[blk].scales[jj] >> 4);
-                if (d_s < 1e-15f) {
-                    q_cont_all[i] = 0.0f;
-                    q_base_all[i] = 0;
-                } else {
-                    /* Quantize the DC-adjusted target */
-                    float qc = (adj_block_x[i] + m_s) / d_s;
-                    q_cont_all[i] = qc;
-                    int qr = gguf_nearest_int(qc);
-                    if (qr < 0) qr = 0; if (qr > 3) qr = 3;
-                    q_base_all[i] = qr;
-                }
-            }
+            hex_vesica_bake_subcodes(
+                block_x,
+                imat_importance ? (imat_importance + blk * QK_K) : NULL,
+                dm, mm, Ls_blk, Lm_blk, L, 0);
+            int q_base_all[QK_K];
+            int q_shaped_all[QK_K];
+            for (int i = 0; i < QK_K; i++)
+                q_base_all[i] = (int)L[i];
             memcpy(q_shaped_all, q_base_all, QK_K * sizeof(int));
 
             float e_live[QK_K];
@@ -4028,19 +4492,26 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                  * d_s == 0 (NOT 0 — the −dmin·lm term always applies). */
                 float deq = d_s * (float)q_shaped_all[i] - m_s;
                 /* Residual against the adjusted target (DC-corrected view) */
-                e_live[i] = adj_block_x[i] - deq;
+                e_live[i] = block_x[i] - deq;
             }
 
             float v_live[QK_K / 2];
-            float vesica_cur = 0.0f, dc_cur = 0.0f;
+            float vesica_cur = 0.0f, dc_cur = 0.0f, cross_cur = 0.0f;
             for (int i = 0; i < QK_K / 2; i++) {
                 v_live[i] = e_live[i] + e_live[i + QK_K / 2];
                 vesica_cur += v_live[i] * v_live[i];
+                cross_cur  += e_live[i] * e_live[i + QK_K / 2];
             }
             for (int i = 0; i < QK_K; i++) dc_cur += e_live[i];
-            float metric_cur = 4.0f * vesica_cur + dc_cur * dc_cur;
+            float sse_cur = 0.0f;
+            for (int i = 0; i < QK_K; i++) {
+                float w = (imat_importance) ? imat_importance[blk * QK_K + i] : 1.0f;
+                sse_cur += w * e_live[i] * e_live[i];
+            }
+            float metric_cur = HEX_VESICA_SSE_EPS * sse_cur
+                             + hex_spectral_from_moments(dc_cur, vesica_cur, QK_K);
 
-            /* Deterministic greedy descent: accept only strict improvements */
+            /* Deterministic greedy: Edge SSE + Vertex/DC in one metric. */
             for (int pass = 0; pass < QK_K; pass++) {
                 int   best_k     = -1;
                 int   best_q_alt = 0;
@@ -4054,22 +4525,24 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                     int   q_cur = q_shaped_all[k];
                     float m_s   = mm * (float)(output[blk].scales[jj] >> 4);
                     int   pi    = (k < QK_K / 2) ? k : k - QK_K / 2;
+                    float wk    = (imat_importance) ? imat_importance[blk * QK_K + k] : 1.0f;
 
-                    /* Try ALL alternate codes, not just ±1.  A weight at q=0
-                     * with strong positive DC bias may need to jump to q=2 or
-                     * q=3; the old ±1 path took multiple passes to walk there
-                     * one step at a time, if it got there at all. */
                     for (int q_try = 0; q_try <= 3; q_try++) {
                         if (q_try == q_cur) continue;
 
-                        float e_new = adj_block_x[k] - (d_s * (float)q_try - m_s);
+                        float e_new = block_x[k] - (d_s * (float)q_try - m_s);
                         float de    = e_new - e_live[k];
 
                         float v_new = v_live[pi] + de;
 
                         float vesica_alt = vesica_cur - v_live[pi]*v_live[pi] + v_new*v_new;
                         float dc_alt     = dc_cur + de;
-                        float delta      = metric_cur - (4.0f * vesica_alt + dc_alt * dc_alt);
+                        float sse_alt    = sse_cur
+                            - wk * e_live[k] * e_live[k]
+                            + wk * e_new * e_new;
+                        float met_alt = HEX_VESICA_SSE_EPS * sse_alt
+                            + hex_spectral_from_moments(dc_alt, vesica_alt, QK_K);
+                        float delta = metric_cur - met_alt;
 
                         if (delta > best_delta) {
                             best_delta = delta;
@@ -4086,13 +4559,18 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                     int   jj_c  = best_k >> 4;
                     float d_c   = dm * (float)(output[blk].scales[jj_c] & 0xF);
                     float m_c   = mm * (float)(output[blk].scales[jj_c] >> 4);
-                    float e_new_c = adj_block_x[best_k] - (d_c * (float)best_q_alt - m_c);
+                    float e_new_c = block_x[best_k] - (d_c * (float)best_q_alt - m_c);
                     float de_c    = e_new_c - e_live[best_k];
                     int   pi_c    = (best_k < QK_K / 2) ? best_k : best_k - QK_K / 2;
                     float v_new_c = v_live[pi_c] + de_c;
+                    float wk_c    = (imat_importance)
+                        ? imat_importance[blk * QK_K + best_k] : 1.0f;
+                    sse_cur      += wk_c * (e_new_c * e_new_c
+                                            - e_live[best_k] * e_live[best_k]);
                     vesica_cur   += v_new_c * v_new_c - v_live[pi_c] * v_live[pi_c];
                     dc_cur       += de_c;
-                    metric_cur    = 4.0f * vesica_cur + dc_cur * dc_cur;
+                    metric_cur    = HEX_VESICA_SSE_EPS * sse_cur
+                        + hex_spectral_from_moments(dc_cur, vesica_cur, QK_K);
                     v_live[pi_c]  = v_new_c;
                     e_live[best_k]= e_new_c;
                 }
@@ -4404,8 +4882,8 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                  * candidate against the whole-block penalty with the partner
                  * residuals held fixed — exact coordinate descent on E.    */
                 float pe[QK_K];
-                float sub_sse[16], sub_dc[16], pair_cross[8];
-                float dc_tot = 0.0f, cross_tot = 0.0f;
+                float sub_sse[16], sub_dc[16], pair_ves[8];
+                float dc_tot = 0.0f, ves_tot = 0.0f;
                 for (int j = 0; j < N_SUB; j++) {
                     float d_sub = dm * (float)pl_Ls[j];
                     float m_sub = mm * (float)pl_Lm[j];
@@ -4424,10 +4902,12 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                     dc_tot += sub_dc[j];
                 }
                 for (int p = 0; p < 8; p++) {
-                    pair_cross[p] = 0.0f;
-                    for (int k = 0; k < 16; k++)
-                        pair_cross[p] += pe[16*p + k] * pe[16*(p+8) + k];
-                    cross_tot += pair_cross[p];
+                    pair_ves[p] = 0.0f;
+                    for (int k = 0; k < 16; k++) {
+                        float v = pe[16*p + k] + pe[16*(p+8) + k];
+                        pair_ves[p] += v * v;
+                    }
+                    ves_tot += pair_ves[p];
                 }
 
                 for (int j = 0; j < N_SUB; j++) {
@@ -4436,12 +4916,12 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                     int   pj         = j ^ 8;          /* partner sub-block  */
                     const float *ppe = pe + 16 * pj;   /* partner residuals  */
                     float dc_rest    = dc_tot    - sub_dc[j];
-                    float cross_rest = cross_tot - pair_cross[pi];
+                    float ves_rest   = ves_tot   - pair_ves[pi];
 
                     /* Extended score of the CURRENT committed state */
                     float best_sub = sub_sse[j]
                         + (HEX_DC_LAMBDA / (float)QK_K) * dc_tot * dc_tot
-                        + (HEX_VW_LAMBDA / (float)QK_K) * 4.0f * cross_tot;
+                        + (HEX_VW_LAMBDA / (float)QK_K) * ves_tot;
                     int     best_ls = -1, best_lm = 0;
                     uint8_t best_q[16];
                     float   best_e[16];
@@ -4470,10 +4950,10 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                                 e_loc[k] = e;
                                 sub_err += e * e * w;
                                 dcc     += e;
-                                cxc     += e * ppe[k];
-                                /* SSE-partial prune is a valid lower bound
-                                 * only while the spectral terms are ≥ 0,
-                                 * i.e. when the (signable) vw credit is off */
+                                {
+                                    float vpk = e + ppe[k];
+                                    cxc += vpk * vpk;
+                                }
                                 if (HEX_VW_LAMBDA == 0.0f &&
                                     sub_err >= best_sub) { aborted = 1; break; }
                             }
@@ -4481,8 +4961,8 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                             float score = sub_err
                                 + (HEX_DC_LAMBDA / (float)QK_K)
                                   * (dc_rest + dcc) * (dc_rest + dcc)
-                                + (HEX_VW_LAMBDA / (float)QK_K) * 4.0f
-                                  * (cross_rest + cxc);
+                                + (HEX_VW_LAMBDA / (float)QK_K)
+                                  * (ves_rest + cxc);
                             if (score < best_sub) {
                                 best_sub = score;
                                 best_ls  = try_ls;
@@ -4503,9 +4983,9 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                         memcpy(pe + 16 * j, best_e, sizeof(best_e));
                         sub_sse[j]     = best_sse;
                         sub_dc[j]      = best_dcc;
-                        pair_cross[pi] = best_cxc;
+                        pair_ves[pi]   = best_cxc;
                         dc_tot         = dc_rest    + best_dcc;
-                        cross_tot      = cross_rest + best_cxc;
+                        ves_tot        = ves_rest   + best_cxc;
                         pol_improved = 1;
                     }
                 }
@@ -4666,20 +5146,34 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
             output[blk].dmin = gguf_fp32_to_fp16(mm);
         }
 
-        /* ══ PHASE 4.7: CANDIDATE FLOOR (worst-case bound) ══
+        /* Bake vesica subcodes into stock 2-bit + nibble fields.
+         * Accept only if block SSE drops; 4.7 is the backstop. */
+        {
+            uint8_t gLs[16], gLm[16];
+            const float *wrow = imat_importance
+                ? (imat_importance + blk * QK_K) : NULL;
+            for (int sj = 0; sj < N_SUB; sj++) {
+                gLs[sj] = output[blk].scales[sj] & 0xF;
+                gLm[sj] = output[blk].scales[sj] >> 4;
+            }
+            hex_vesica_commit(block_x, wrow, &dm, &mm, gLs, gLm, L);
+            for (int sj = 0; sj < N_SUB; sj++)
+                output[blk].scales[sj] = gLs[sj] | (gLm[sj] << 4);
+            output[blk].d    = gguf_fp32_to_fp16(dm);
+            output[blk].dmin = gguf_fp32_to_fp16(mm);
+            memcpy(Ls_blk, gLs, 16);
+            memcpy(Lm_blk, gLm, 16);
+        }
+
+        /* ══ PHASE 4.7: CANDIDATE FLOOR ══
          *
-         * candidate_errors[blk][c] is the EXACT weighted SSE of a directly
-         * encodable configuration (fp16 d/dmin + derived Ls/Lm + nearest
-         * rounding vs the original weights). The multi-stage assembly
-         * (DC-shifted WLS, shaping, diffusion, polish) usually improves on
-         * its seed, but each stage optimises a slightly different objective
-         * and coordinate descent can land in a worse basin. Compare the
-         * finished block against the best raw candidate and fall back when
-         * the pipeline ended up worse — guaranteeing
-         *     final weighted SSE ≤ min_c candidate_errors[blk][c].          */
+         * candidate_errors is pure nearest-int SSE (the "theoretical floor"
+         * Fold beat by changing coordinates). Compare that to pipeline SSE
+         * only — never SSE+spectral. Adding the vesica/DC penalty here made
+         * fin_err > g_best whenever λ>0, so every block snapped back to
+         * independent nearest-int and threw away HPC+triality+vesica. */
         {
             float fin_err = 0.0f;
-            float e_f[QK_K];
             for (int j = 0; j < N_SUB; j++) {
                 float d_sub = dm * (float)(output[blk].scales[j] & 0xF);
                 float m_sub = mm * (float)(output[blk].scales[j] >> 4);
@@ -4687,12 +5181,11 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
                     int   idx = 16 * j + k;
                     float w   = (imat_importance) ?
                                 imat_importance[blk * QK_K + idx] : 1.0f;
-                    e_f[idx] = block_x[idx] -
-                               (d_sub * (float)L[idx] - m_sub);
-                    fin_err += e_f[idx] * e_f[idx] * w;
+                    float e = block_x[idx] -
+                              (d_sub * (float)L[idx] - m_sub);
+                    fin_err += e * e * w;
                 }
             }
-            fin_err += hex_spectral_penalty(e_f, QK_K);
 
             float g_best = candidate_errors[blk][0];
             int   g_cand = 0;
@@ -4732,6 +5225,22 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
             }
         }
 
+            if (HEX_VW_LAMBDA != 0.0f || HEX_DC_LAMBDA != 0.0f) {
+            uint8_t gLs[16], gLm[16];
+            const float *wrow = imat_importance
+                ? (imat_importance + blk * QK_K) : NULL;
+            for (int sj = 0; sj < N_SUB; sj++) {
+                gLs[sj] = output[blk].scales[sj] & 0xF;
+                gLm[sj] = output[blk].scales[sj] >> 4;
+            }
+            float sse_pre = hex_block_sse(block_x, wrow, dm, mm, gLs, gLm, L);
+            uint8_t Lpre[QK_K];
+            memcpy(Lpre, L, QK_K);
+            hex_vesica_guide_pairs(block_x, wrow, dm, mm, gLs, gLm, L);
+            if (hex_block_sse(block_x, wrow, dm, mm, gLs, gLm, L) > sse_pre)
+                memcpy(L, Lpre, QK_K);
+        }
+
         for (int j = 0; j < QK_K; j += 128) {
             for (int l = 0; l < 32; l++) {
                 output[blk].qs[j / 4 + l] = L[j + l]
@@ -4758,6 +5267,8 @@ static void quantize_tensor_q2k_hpc(const float *weights, int64_t n_elements,
     free(seeds);
     free(candidate_errors);
     free(best_candidate);
+    free(fold_w);
+    free(fold_i);
     if (out_total_error) *out_total_error = total_err;
     
     if (verbose) {