From ae59c6ff198f198dfc66e29682623a821234aae6 Mon Sep 17 00:00:00 2001
From: Xiao-Yong Jin <xjin@anl.gov>
Date: Wed, 11 Mar 2026 16:29:50 -0500
Subject: [PATCH 1/7] HYP refactored with higher order derivatives

---
 src/field/fieldET.nim                         |   37 +-
 src/gauge/gaugeAction.nim                     |    2 +-
 src/gauge/gaugeUtils.nim                      |   36 +
 src/gauge/hypsmear.nim                        | 1479 ++++++++++++----
 src/gauge/hypsmear2.nim                       |   10 +-
 src/gauge/smearutil.nim                       |  535 ++++++
 src/maths/matrixFunctions.nim                 |  408 ++++-
 src/physics/colorOld.nim                      |   45 +
 tests/deriv/tgaugeaction.nim                  |  164 ++
 tests/deriv/thyp.nim                          |  963 ++++++++++
 tests/deriv/tprojU.nim                        |  677 +++++++
 .../tstoutderiv.nim => deriv/tstout.nim}      |  112 +-
 tests/deriv/tsymstaple.nim                    | 1574 +++++++++++++++++
 tests/deriv/utils.nim                         |  800 +++++++++
 14 files changed, 6435 insertions(+), 407 deletions(-)
 create mode 100644 tests/deriv/tgaugeaction.nim
 create mode 100644 tests/deriv/thyp.nim
 create mode 100644 tests/deriv/tprojU.nim
 rename tests/{base/tstoutderiv.nim => deriv/tstout.nim} (52%)
 create mode 100644 tests/deriv/tsymstaple.nim
 create mode 100644 tests/deriv/utils.nim

diff --git a/src/field/fieldET.nim b/src/field/fieldET.nim
index 273658f2..51feb69b 100644
--- a/src/field/fieldET.nim
+++ b/src/field/fieldET.nim
@@ -20,8 +20,8 @@ type
     l*:Layout[V]
     elemSize*:int
   Field*[V:static[int],T] = ref FieldObj[V,T]
-  FieldArray*[V:static[int],T] = object  ## share a single alignedMem
-    shape*:seq[int]
+  FieldArray*[N:static[int],V:static[int],T] = object  ## share a single alignedMem
+    shape*:array[N,int]
     arr:seq[Field[V,T]]
   Subsetted*[F,S] = object
     field*:F
@@ -181,8 +181,8 @@ proc newFarrElem[V:static[int],T](f:var Field[V,T]; l:Layout[V]; s:alignedMem[T]
   f.s.data = cast[typeof(s.data)](cast[int](s.data) + offset*l.nSitesOuter*s.stride)
   f.elemSize = sizeOf(T)
 
-proc newFieldArray*[V:static[int],T](l:Layout[V]; t:typedesc[Field[V,T]]; n: int):FieldArray[V,T] {.noinit.} =
-  result.shape = @[n]
+proc newFieldArray*[V:static[int],T](l:Layout[V]; t:typedesc[Field[V,T]]; n: int):FieldArray[1,V,T] {.noinit.} =
+  result.shape[0] = n
   result.arr = newseq[t](n)
   var s:typeof(result.arr[0].s)
   s.newU(l.nSitesOuter*n)
@@ -193,8 +193,9 @@ template newFieldArray2*[V:static[int],T](l:Layout[V]; ty:typedesc[Field[V,T]];
     ns: array[2,int]; constraint: untyped):untyped =
   let n = ns[0]
   let m = ns[1]
-  var r {.noinit.} :FieldArray[V,T]
-  r.shape = @[n,m]
+  var r {.noinit.} :FieldArray[2,V,T]
+  r.shape[0] = n
+  r.shape[1] = m
   r.arr = newseq[ty](n*m)
   var t = 0
   for i in 0..<n:
@@ -216,7 +217,7 @@ template newFieldArray2*[V:static[int],T](l:Layout[V]; ty:typedesc[Field[V,T]];
       inc k
   r
 
-proc newOneOf*[V:static[int],T](fa:FieldArray[V,T]):FieldArray[V,T] {.noinit.} =
+proc newOneOf*[N:static[int],V:static[int],T](fa:FieldArray[N,V,T]):FieldArray[N,V,T] {.noinit.} =
   result.shape = fa.shape
   result.arr = newseq[Field[V,T]](fa.arr.len)
   var s:typeof(fa.arr[0].s)
@@ -235,6 +236,28 @@ proc newOneOf*[V:static[int],T](fa:FieldArray[V,T]):FieldArray[V,T] {.noinit.} =
     newFarrElem(result.arr[i], l, s, t)
     inc t
 
+proc copyFieldArray*[N:static[int],V:static[int],T](
+    dst: FieldArray[N,V,T];
+    src: FieldArray[N,V,T]
+  ) =
+  doAssert dst.arr.len == src.arr.len, "FieldArray size mismatch"
+  doAssert dst.shape == src.shape, "FieldArray shape mismatch"
+  for i in 0..<src.arr.len:
+    doAssert (src.arr[i] == nil) == (dst.arr[i] == nil),
+      "FieldArray nil pattern mismatch"
+    if src.arr[i] == nil:
+      continue
+    when compiles(assignM(dst.arr[i], src.arr[i])):
+      assignM(dst.arr[i], src.arr[i])
+    else:
+      dst.arr[i] := src.arr[i]
+
+template `:=`*[N:static[int],V:static[int],T](
+    dst: FieldArray[N,V,T];
+    src: FieldArray[N,V,T]
+  ) =
+  copyFieldArray(dst, src)
+
 template dataPtr*[V:static[int],T](x: Field[V,T]): auto = x.s.data
 template isWrapper*(x: SomeField): bool = false
 template isWrapper*(x: typedesc[SomeField]): bool = false
diff --git a/src/gauge/gaugeAction.nim b/src/gauge/gaugeAction.nim
index 1133b19b..745806ae 100644
--- a/src/gauge/gaugeAction.nim
+++ b/src/gauge/gaugeAction.nim
@@ -158,7 +158,7 @@ proc gaugeActionDeriv*[T](c: GaugeActionCoeffs, uu: openArray[T], f: array|seq,
   let cp = c.plaq / float(nc)
   let cr = c.rect / float(nc)
   var cs = startCornerShifts(uu)
-  var ru:FieldArray[type(u[0]).V,type(u[0]).T]  # the rect parts of 3
+  var ru:FieldArray[2,type(u[0]).V,type(u[0]).T]  # the rect parts of 3
   var sb:seq[seq[ShiftB[type(u[0][0])]]]  # backward ru
   var sf:seq[seq[ShiftB[type(u[0][0])]]]  # forward stf
   if cr!=0:
diff --git a/src/gauge/gaugeUtils.nim b/src/gauge/gaugeUtils.nim
index a7741868..4a263b2e 100644
--- a/src/gauge/gaugeUtils.nim
+++ b/src/gauge/gaugeUtils.nim
@@ -414,6 +414,42 @@ proc contractProjectTAH*[T](g:openArray[T], f:openArray[T]) =
         let s = u[mu][e]*o[mu][e].adj
         o[mu][e].projectTAH s
 
+proc contractProjectTAHVJP*[T](g: openArray[T], f: openArray[T],
+                                fbar: openArray[T],
+                                dbar: openArray[T], ubar: openArray[T]) =
+  ## VJP of contractProjectTAH.
+  ##
+  ## Forward: F = projectTAH(U · D†)
+  ##
+  ## Given F̄ (adjoint seed), computes:
+  ##   D̄ = adjoint w.r.t. D (the input force before contraction)
+  ##   Ū = adjoint w.r.t. U (the gauge field)
+  ##
+  ## Mathematical derivation:
+  ##   dT = ⟨F̄, dF⟩ = ⟨F̄, projectTAH(U · dD†)⟩
+  ##   Since projectTAH is self-adjoint on TAH: = ⟨projectTAH(F̄), U · dD†⟩
+  ##   = Re⟨projectTAH(F̄)† · U, dD⟩
+  ##
+  ## Since projectTAH output is anti-Hermitian: X† = -X
+  ## So: D̄ = projectTAH(F̄)† · U = -projectTAH(F̄) · U
+  ##
+  ## For Ū: dT = ⟨F̄, projectTAH(dU · D†)⟩ = ⟨projectTAH(F̄), dU · D†⟩
+  ##   = Re⟨projectTAH(F̄) · D, dU⟩
+  ## So: Ū = projectTAH(F̄) · D
+  let nd = g.len
+  let u = cast[ptr cArray[T]](unsafeAddr(g[0]))
+  let d = cast[ptr cArray[T]](unsafeAddr(f[0]))
+  let fb = cast[ptr cArray[T]](unsafeAddr(fbar[0]))
+  let db = cast[ptr cArray[T]](unsafeAddr(dbar[0]))
+  let ub = cast[ptr cArray[T]](unsafeAddr(ubar[0]))
+  threads:
+    for mu in 0..<nd:
+      for e in u[mu]:
+        var pf {.noInit.}: type(fb[0][0])
+        pf.projectTAH fb[mu][e]  # projectTAH(F̄)
+        db[mu][e] := -pf * u[mu][e]  # D̄ = -projectTAH(F̄) · U
+        ub[mu][e] := pf * d[mu][e]   # Ū = projectTAH(F̄) · D
+
 type
   Link[F:ref] = object
     field:F
diff --git a/src/gauge/hypsmear.nim b/src/gauge/hypsmear.nim
index 6c22e280..b4bb6dbd 100644
--- a/src/gauge/hypsmear.nim
+++ b/src/gauge/hypsmear.nim
@@ -12,6 +12,10 @@ type HypCoefs* = object
   alpha2*: float
   alpha3*: float
 
+type HypScaleFactors = object
+  alp1, alp2, alp3: float
+  ma1, ma2, ma3: float
+
 proc `$`*(c: HypCoefs): string =
   result = "Hyp{\n"
   result &= "  alpha1: " & $c.alpha1 & "\n"
@@ -35,6 +39,96 @@ template projDeriv(r: auto, u, x: auto, c: auto) =
   for i in r:
     r[i].projectUDeriv(u[i], x[i], c[i])
 
+template projVJP(r: auto, x: auto, c: auto) =
+  ## Alias for projDeriv (kernel VJP).
+  projDeriv(r, x, c)
+
+template projVJP(r: auto, u, x: auto, c: auto) =
+  ## Alias for projDeriv (kernel VJP) with explicit projected link.
+  projDeriv(r, u, x, c)
+
+template projHVP(r: auto, x: auto, c: auto, dx: auto) =
+  ## Gauge-field wrapper for the directional second derivative of the unitary
+  ## projection backprop.  Applies projectUHVP site-by-site.
+  for i in r:
+    r[i].projectUHVP(x[i], c[i], dx[i])
+
+template projHVPu(r: auto, u, x: auto, c: auto, dx: auto) =
+  ## Variant taking both the projected link u and the pre-projection x.
+  for i in r:
+    r[i].projectUHVPu(u[i], x[i], c[i], dx[i])
+
+template projHVP(r: auto, x: auto, c: auto, dx: auto, dc: auto) =
+  ## Variant that also propagates a chain tangent dc alongside dx.
+  for i in r:
+    r[i].projectUHVP(x[i], c[i], dx[i], dc[i])
+
+template projHVPu(r: auto, u, x: auto, c: auto, dx: auto, dc: auto) =
+  ## Variant taking both projected link u and upstream tangent dc.
+  for i in r:
+    r[i].projectUHVPu(u[i], x[i], c[i], dx[i], dc[i])
+
+template projJVP(r: auto, u, x: auto, dx: auto) =
+  ## Forward tangent of unitary projection at field level.
+  for i in r:
+    r[i].projectUJVP(u[i], x[i], dx[i])
+
+template projJVP(r: auto, x: auto, dx: auto) =
+  ## Forward tangent without providing u.
+  for i in r:
+    r[i].projectUJVP(x[i], dx[i])
+
+template projVJPChain(chainbar: auto, u, x: auto, rbar: auto) =
+  ## Adjoint of projVJP with respect to the chain input.
+  ## Given rbar (the adjoint seed), computes chainbar.
+  for i in chainbar:
+    chainbar[i].projectUVJPChain(u[i], x[i], rbar[i])
+
+template projVJPChain(chainbar: auto, x: auto, rbar: auto) =
+  ## Variant without providing u.
+  for i in chainbar:
+    chainbar[i].projectUVJPChain(x[i], rbar[i])
+
+template projHVPVJP_dx(dxbar: auto, u, x: auto, c: auto, rbar: auto) =
+  ## Adjoint of projHVP with respect to dx.
+  ## Given rbar (the adjoint seed), computes dxbar.
+  for i in dxbar:
+    dxbar[i].projectUHVPVJP_dx(u[i], x[i], c[i], rbar[i])
+
+template projHVPVJP_dx(dxbar: auto, x: auto, c: auto, rbar: auto) =
+  ## Variant without providing u (computes u = projectU(x) internally).
+  for i in dxbar:
+    dxbar[i].projectUHVPVJP_dx(x[i], c[i], rbar[i])
+
+template projHVPVJP_dc(dcbar: auto, u, x: auto, c: auto, rbar: auto) =
+  ## Adjoint of projHVP with respect to dc (chain tangent).
+  ## Given rbar (the adjoint seed), computes dcbar.
+  for i in dcbar:
+    dcbar[i].projectUHVPVJP_dc(u[i], x[i], c[i], rbar[i])
+
+template projHVPVJP_dc(dcbar: auto, x: auto, c: auto, rbar: auto) =
+  ## Variant without providing u (computes u = projectU(x) internally).
+  for i in dcbar:
+    dcbar[i].projectUHVPVJP_dc(x[i], c[i], rbar[i])
+
+template forPairs(mu, nu: untyped; body: untyped) =
+  for mu in 0..<4:
+    for nu in 0..<4:
+      if nu != mu:
+        body
+
+template forNu(mu, nu: untyped; body: untyped) =
+  for nu in 0..<4:
+    if nu != mu:
+      body
+
+template forThird(mu, nu, a, b: untyped; body: untyped) =
+  for a in 0..<4:
+    if a != mu and a != nu:
+      let b = 1 + 2 + 3 - mu - nu - a
+      discard b
+      body
+
 # L[mu][nu] = P( (1-a1)*g[mu] + 0.5*a1 SS(g[nu],g[mu]) )
 # L2[mu][nu] = P( (1-a2)*g[mu] + 0.25*a2 sum{a,b!=mu,nu} SS(L[a][b],L[mu][b]) )
 # fl[mu] = P( (1-a3)*g[mu] + a3/6 sum{nu!=mu} SS(L2[nu][mu],L2[mu][nu]) )
@@ -45,342 +139,1109 @@ proc smearGetForce*[G](coef: HypCoefs, gf: G, fl: G,
   ## Note that the resulting proc, smearedForce, holds a reference to the input gauge gf.
   ## The correctness of the algorithm depends on gf remaining the same.
   ## On the contrary, any changes to the smeared gauge fl would have no effects to the force calculation.
-  tic()
-  type lcm = type(gf[0])
   let lo = gf[0].l
-  proc newlcm: lcm = result.new(gf[0].l)
-  var
-    l1x = newFieldArray2(lo,lcm,[4,4],mu!=nu)
-    l2x = newOneOf(l1x)
-    flx = newFieldArray(lo,lcm,4)
-    tm1: lcm
-    sm1: array[4,Shifter[lcm,type(gf[0][0])]]
-    s1: array[4,array[4,Shifter[lcm,type(gf[0][0])]]]
-    #nflop = 61632.0
-    #dtime = 0.0
-  when keepProj:
-    var
-      l1 = newOneOf(l1x)
-      l2 = newOneOf(l1x)
-  else:
-    var
-      lp1 = newlcm()
-      lp2 = newlcm()
+  var hs = lo.newHypSmear(coef)
+  hs.smear(gf, fl)
+  discard info
+  proc smearedForce(f, chain: G) =
+    hs.smearVJP(f, chain)
+  smearedForce
 
-  tm1 = newlcm()
+proc smearPriv[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) {.codegenDecl:
+    "__attribute__((noinline)) $# $#$#".} =
+  # Avoid inlining or other compiler optimizations
+  # in order to guarantee the change of the stack pointer,
+  # such that Nim's GC is able to collect the memory.
+  {.emit: "asm (\"\");".}
+  let lo = gf[0].l
+  var hs = lo.newHypSmear(coef)
+  hs.smear(gf, fl)
+  discard info
+proc smear*[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) =
+  ## Try our best to release memory here.
+  ## Sometimes it still requires a GC after this function returns.
+  coef.smearPriv(gf, fl, info)
+  qexGC()
+
+#proc smear*(c: HypCoefs, gf: auto, fl: auto, info: var PerfInfo) =
+#  var t = newHypTemps(gf)
+#  smear(c, gf, fl, t, info)
+
+proc smear*(c: HypCoefs, g: auto, fl: auto) =
+  var info: PerfInfo
+  c.smear(g, fl, info)
+
+#proc deriv*(coef: HypCoefs, gf: auto, fl: auto, info: var PerfInfo) =
+#  ## Compatibility wrapper around the shared forward HYP builder.
+#  coef.smear(gf, fl, info)
+
+# Preallocated HYP smearing environment, following stoutsmear style
+type
+  HypForwardState[L,F,T] = object
+    ## Persistent state produced by `smear` and consumed by derivative passes.
+    gf*: array[4,F]
+    ## Dedicated shifters for pair terms built directly from the original gauge
+    ## links. These buffers stay stable after `smear`, so later passes do not
+    ## need to restore any hidden cached field pointers.
+    gaugePairShift*: array[4,array[4,Shifter[F,T]]]
+    ## Separate shifters for projected Level-1/Level-2 pair terms. Keeping
+    ## these distinct from `gaugePairShift` avoids mutating a single shifter set
+    ## between gauge and projected-link phases.
+    stagePairShift*: array[4,array[4,Shifter[F,T]]]
+    sm1*: array[4,Shifter[F,T]]
+    l1x*, l2x*: FieldArray[2,L.V,T]
+    when keepProj:
+      l1*, l2*: FieldArray[2,L.V,T]
+    flx*: FieldArray[1,L.V,T]
+
+  HypScratch[L,F,T] = object
+    ## Mutable work buffers used by reverse/tangent passes.
+    ## Post-projection chain values for the output, Level 1, and Level 2
+    ## reverse passes. These are scratch, not cached forward state.
+    outputChain*: FieldArray[1,L.V,T]
+    level1Chain*, level2Chain*: FieldArray[2,L.V,T]
+    ## Pre-projection chain values saved specifically for second-order
+    ## projection adjoints.
+    preProjLevel1Chain*, preProjLevel2Chain*: FieldArray[2,L.V,T]
+    ## Reusable forward shifters indexed by direction. `chainShift` is used for
+    ## active chain fields, while `seedShift` stays available as a second
+    ## scratch pool when the higher-order adjoints need an extra shifted seed.
+    chainShift*: array[4,Shifter[F,T]]
+    seedShift*: array[4,Shifter[F,T]]
+    tm1*, tm2*: F
+
+  HypSmear*[L,F,T] = object
+    ## Reusable buffers for HYP smearing and its derivative.
+    ##
+    ## The forward state is intentionally separated from the mutable scratch so
+    ## it is clear which fields are part of the cached smear result and which
+    ## are transient workspaces for reverse/tangent evaluations.
+    coef*: HypCoefs
+    state*: HypForwardState[L,F,T]
+    work*: HypScratch[L,F,T]
+
+  HypTangentState[GaugeTangent, OutputTangent, PairField, PairShift] = object
+    dgEff*: GaugeTangent
+    dl1x*, dl1*: PairField
+    dl2x*, dl2*: PairField
+    dflx*: OutputTangent
+    dsl2*: PairShift
+
+  HypHvpWorkspace[GaugeField, PairField] = object
+    dOutputChain*: GaugeField
+    dLevel1Chain*, dLevel2Chain*: PairField
+    dPreProjLevel1Chain*, dPreProjLevel2Chain*: PairField
+
+  HypChainAdjointWorkspace[GaugeField, PairField] = object
+    outputChainBar*: GaugeField
+    level1ChainBar*, level2ChainBar*: PairField
+
+  HypHvpAdjointWorkspace[GaugeField, PairField] = object
+    dflxbar*, dfcbar*, dgEffbar*: GaugeField
+    dfl1bar*, dfl2bar*: PairField
+    dl1bar*, dl2bar*: PairField
+    dl1xbar*, dl2xbar*: PairField
+    dfl1barL2*, dfl2barL3*: PairField
+
+  HypLevel3HvpScratch[PairField, ShiftField] = object
+    shiftedOutputChain*: ShiftField
+    acc1*, acc2*: PairField
+
+  HypLevel3AdjointScratch[GaugeField] = object
+    dcbar*: GaugeField
+
+proc scaleFactors[L,F,T](hs: HypSmear[L,F,T]): HypScaleFactors {.inline.} =
+  result = HypScaleFactors(
+    alp1: hs.coef.alpha1 / 2.0,
+    alp2: hs.coef.alpha2 / 4.0,
+    alp3: hs.coef.alpha3 / 6.0,
+    ma1: 1 - hs.coef.alpha1,
+    ma2: 1 - hs.coef.alpha2,
+    ma3: 1 - hs.coef.alpha3,
+  )
+
+proc newHypSmear*(l: Layout, coef: HypCoefs): auto =
+  ## Allocate a reusable environment for HYP smearing and derivatives
+  type F = type(l.newGauge[0])
+  type T = type(l.newGauge[0][0])
+  type L = type(l)
+  var hs: HypSmear[L,F,T]
+  hs.coef = coef
+  hs.state.l1x = newFieldArray2(l,F,[4,4],mu!=nu)
+  hs.state.l2x = newFieldArray2(l,F,[4,4],mu!=nu)
+  when keepProj:
+    hs.state.l1 = newFieldArray2(l,F,[4,4],mu!=nu)
+    hs.state.l2 = newFieldArray2(l,F,[4,4],mu!=nu)
+  hs.state.flx = newFieldArray(l,F,4)
+  hs.work.outputChain = newFieldArray(l,F,4)
+  hs.work.level1Chain = newFieldArray2(l,F,[4,4],mu!=nu)
+  hs.work.level2Chain = newFieldArray2(l,F,[4,4],mu!=nu)
+  hs.work.preProjLevel1Chain = newFieldArray2(l,F,[4,4],mu!=nu)
+  hs.work.preProjLevel2Chain = newFieldArray2(l,F,[4,4],mu!=nu)
+  hs.work.tm1.new(l)
+  hs.work.tm2.new(l)
   for mu in 0..<4:
-    sm1[mu] = newShifter(gf[mu], mu, -1)
+    hs.state.sm1[mu] = newShifter(hs.work.outputChain[mu], mu, -1)
+    hs.work.chainShift[mu] = newShifter(hs.work.outputChain[mu], mu, 1)
+    hs.work.seedShift[mu] = newShifter(hs.work.outputChain[mu], mu, 1)
     for nu in 0..<4:
-      if nu!=mu:
-        s1[mu][nu] = newShifter(gf[mu], nu, 1)
+      if nu != mu:
+        hs.state.gaugePairShift[mu][nu] = newShifter(hs.work.outputChain[mu], nu, 1)
+        hs.state.stagePairShift[mu][nu] = newShifter(hs.work.outputChain[mu], nu, 1)
+  hs
+
+proc initProjectedLevelsImpl(hs: var HypSmear; l1, l2: var auto;
+                             populateFromCache: static bool) =
+  when keepProj:
+    l1 = hs.state.l1
+    l2 = hs.state.l2
+  else:
+    let lo = hs.state.gf[0].l
+    type Fld = typeof(hs.state.gf[0])
+    l1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+    l2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+    when populateFromCache:
+      threads:
+        forPairs(mu, nu):
+          l1[mu,nu].proj hs.state.l1x[mu,nu]
+          l2[mu,nu].proj hs.state.l2x[mu,nu]
+
+proc initProjectedLevels(hs: var HypSmear; l1, l2: var auto) =
+  initProjectedLevelsImpl(hs, l1, l2, true)
+
+proc buildGaugeTangent(gf, dg: auto): auto =
+  let lo = gf[0].l
+  var dgEff = lo.newGauge
+  threads:
+    for mu in 0..<gf.len:
+      dgEff[mu] := dg[mu] * gf[mu]
+  dgEff
+
+proc initShiftedTangents(f: auto): auto =
+  var s: array[4,array[4,Shifter[type(f[0]),type(f[0][0])]]]
+  forPairs(mu, nu):
+    s[mu][nu] = newShifter(f[mu], nu, 1)
+  threads:
+    forPairs(mu, nu):
+      discard s[mu][nu] ^*! f[mu]
+  s
+
+proc initForwardProjectedLevels(hs: var HypSmear; l1, l2: var auto) =
+  ## Allocate the projected Level-1/Level-2 buffers used while rebuilding the
+  ## forward HYP state. Unlike `initProjectedLevels`, this does not populate the
+  ## buffers from cached state.
+  initProjectedLevelsImpl(hs, l1, l2, false)
+
+template projectAndScalePairChain(chain, projected, xfield, preProjChain,
+                                  alp, derivSink, ma: untyped;
+                                  accumulateDirect: static bool) =
+  threads:
+    forPairs(mu, nu):
+      preProjChain[mu,nu] := chain[mu,nu]
+      chain[mu,nu].projVJP(projected[mu,nu], xfield[mu,nu], preProjChain[mu,nu])
+
+  threads:
+    forPairs(mu, nu):
+      when accumulateDirect:
+        derivSink[mu] += ma * chain[mu,nu]
+      chain[mu,nu] *= alp
+
+template clearReverseChains(outputChain, level1Chain, level2Chain: auto) =
   threads:
     for mu in 0..<4:
-      for nu in 0..<4:
-        if nu!=mu:
-          discard s1[mu][nu] ^*! gf[mu]
+      outputChain[mu] := 0
+      forNu(mu, nu):
+        level1Chain[mu,nu] := 0
+        level2Chain[mu,nu] := 0
 
-  let
-    alp1 = coef.alpha1 / 2.0
-    alp2 = coef.alpha2 / 4.0
-    alp3 = coef.alpha3 / 6.0
-    ma1 = 1 - coef.alpha1
-    ma2 = 1 - coef.alpha2
-    ma3 = 1 - coef.alpha3
+template clearTangentWorkspace(dflx, dl1x, dl2x, dl1, dl2: auto) =
+  threads:
+    for mu in 0..<4:
+      dflx[mu] := 0
+      forNu(mu, nu):
+        dl1x[mu,nu] := 0
+        dl2x[mu,nu] := 0
+        dl1[mu,nu] := 0
+        dl2[mu,nu] := 0
 
-  toc("prep")
+template clearHvpWorkspace(dderiv, dOutputChain, dLevel1Chain, dLevel2Chain: auto) =
   threads:
     for mu in 0..<4:
-      for nu in 0..<4:
-        if nu!=mu:
-          l1x[mu,nu] := ma1 * gf[mu]
-          symStaple(l1x[mu,nu], alp1, gf[nu], gf[mu],
-                    s1[nu][mu], s1[mu][nu], tm1, sm1[nu])
-          when keepProj:
-            l1[mu,nu].proj l1x[mu,nu]
-    toc("1")
+      dderiv[mu] := 0
+      dOutputChain[mu] := 0
+      forNu(mu, nu):
+        dLevel1Chain[mu,nu] := 0
+        dLevel2Chain[mu,nu] := 0
 
+template clearChainAdjointWorkspace(outputChainBar, chainbar,
+                                    level1ChainBar, level2ChainBar: auto) =
+  threads:
     for mu in 0..<4:
-      for nu in 0..<4:
-        if nu!=mu:
-          l2x[mu,nu] := ma2 * gf[mu]
-          for a in 0..<4:
-            if a!=mu and a!=nu:
-              let b = 1+2+3-mu-nu-a
-              when keepProj:
-                template lp1:untyped = l1[a,b]
-                template lp2:untyped = l1[mu,b]
-              else:
-                lp1.proj l1x[a,b]
-                lp2.proj l1x[mu,b]
-              threadBarrier()
-              discard s1[nu][mu] ^*! lp1
-              discard s1[mu][a] ^*! lp2
-              threadBarrier()
-              symStaple(l2x[mu,nu], alp2, lp1, lp2,
-                        s1[nu][mu], s1[mu][a], tm1, sm1[a])
-          when keepProj:
-            l2[mu,nu].proj l2x[mu,nu]
-    toc("2")
+      outputChainBar[mu] := 0
+      chainbar[mu] := 0
+      forNu(mu, nu):
+        level1ChainBar[mu,nu] := 0
+        level2ChainBar[mu,nu] := 0
 
+template clearHvpAdjointWorkspace(gbar, dflxbar, dfcbar, dgEffbar,
+                                  dfl1bar, dfl2bar, dl1bar, dl2bar,
+                                  dl1xbar, dl2xbar: auto) =
+  threads:
     for mu in 0..<4:
-      flx[mu] := ma3 * gf[mu]
-      for nu in 0..<4:
-        if nu!=mu:
-          when keepProj:
-            template lp1:untyped = l2[nu,mu]
-            template lp2:untyped = l2[mu,nu]
-          else:
-            lp1.proj l2x[nu,mu]
-            lp2.proj l2x[mu,nu]
+      gbar[mu] := 0
+      dflxbar[mu] := 0
+      dfcbar[mu] := 0
+      dgEffbar[mu] := 0
+      forNu(mu, nu):
+        dfl1bar[mu,nu] := 0
+        dfl2bar[mu,nu] := 0
+        dl1bar[mu,nu] := 0
+        dl2bar[mu,nu] := 0
+        dl1xbar[mu,nu] := 0
+        dl2xbar[mu,nu] := 0
+
+proc newHvpWorkspace(gf: auto): auto =
+  let lo = gf[0].l
+  type Fld = typeof(gf[0])
+  var dOutputChain = lo.newGauge
+  var dLevel1Chain = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dLevel2Chain = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dPreProjLevel1Chain = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dPreProjLevel2Chain = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  HypHvpWorkspace[type(dOutputChain), type(dLevel1Chain)](
+    dOutputChain: dOutputChain,
+    dLevel1Chain: dLevel1Chain,
+    dLevel2Chain: dLevel2Chain,
+    dPreProjLevel1Chain: dPreProjLevel1Chain,
+    dPreProjLevel2Chain: dPreProjLevel2Chain,
+  )
+
+proc newChainAdjointWorkspace(chainbar, gf: auto): auto =
+  let lo = gf[0].l
+  type Fld = typeof(gf[0])
+  var outputChainBar = lo.newGauge
+  var level1ChainBar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var level2ChainBar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  clearChainAdjointWorkspace(outputChainBar, chainbar, level1ChainBar, level2ChainBar)
+  HypChainAdjointWorkspace[type(outputChainBar), type(level1ChainBar)](
+    outputChainBar: outputChainBar,
+    level1ChainBar: level1ChainBar,
+    level2ChainBar: level2ChainBar,
+  )
+
+proc newHvpAdjointWorkspace(gbar, gf: auto): auto =
+  let lo = gf[0].l
+  type Fld = typeof(gf[0])
+  var dflxbar = lo.newGauge
+  var dfcbar = lo.newGauge
+  var dgEffbar = lo.newGauge
+  var dfl1bar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dfl2bar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dl1bar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dl2bar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dl1xbar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dl2xbar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  clearHvpAdjointWorkspace(gbar, dflxbar, dfcbar, dgEffbar,
+                           dfl1bar, dfl2bar, dl1bar, dl2bar, dl1xbar, dl2xbar)
+  var dfl1barL2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dfl2barL3 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  HypHvpAdjointWorkspace[type(dflxbar), type(dfl1bar)](
+    dflxbar: dflxbar,
+    dfcbar: dfcbar,
+    dgEffbar: dgEffbar,
+    dfl1bar: dfl1bar,
+    dfl2bar: dfl2bar,
+    dl1bar: dl1bar,
+    dl2bar: dl2bar,
+    dl1xbar: dl1xbar,
+    dl2xbar: dl2xbar,
+    dfl1barL2: dfl1barL2,
+    dfl2barL3: dfl2barL3,
+  )
+
+proc newLevel3HvpScratch(gf, dOutputChain: auto): auto =
+  let lo = gf[0].l
+  type Fld = typeof(gf[0])
+  var shiftedOutputChain: array[4, array[4, Shifter[Fld,type(gf[0][0])]]]
+  forPairs(mu, nu):
+    shiftedOutputChain[mu][nu] = newShifter(dOutputChain[mu], nu, 1)
+  var acc1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var acc2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  HypLevel3HvpScratch[type(acc1), type(shiftedOutputChain)](
+    shiftedOutputChain: shiftedOutputChain,
+    acc1: acc1,
+    acc2: acc2,
+  )
+
+proc newLevel3AdjointScratch(gf: auto): auto =
+  let lo = gf[0].l
+  var dcbar = lo.newGauge
+  threads:
+    for mu in 0..<4:
+      dcbar[mu] := 0
+  HypLevel3AdjointScratch[type(dcbar)](dcbar: dcbar)
+
+template primeLevel3PairShifts(hs, l2: auto) =
+  threads:
+    forPairs(mu, nu):
+      discard hs.state.stagePairShift[mu][nu] ^*! l2[mu,nu]
+
+template forLevel3Pairs(hs, l2, pl1, pl2: untyped; body: untyped) =
+  ## Prime the Level-3 pair shifters once, then iterate over the paired links
+  ## as `(pl1, pl2) = (l2[nu,mu], l2[mu,nu])`.
+  primeLevel3PairShifts(hs, l2)
+
+  threads:
+    forPairs(mu, nu):
+      let pl1 = l2[nu,mu]
+      let pl2 = l2[mu,nu]
+      body
+
+template buildLevel3ReverseChains(hs, l2, outputChain, level2Chain, tm1, tm2: auto) =
+  forLevel3Pairs(hs, l2, pl1, pl2):
+    threadBarrier()
+    discard hs.work.chainShift[nu] ^*! outputChain[mu]
+    threadBarrier()
+    symStapleVJP(level2Chain[nu,mu], level2Chain[mu,nu],
+                 pl1, pl2,
+                 hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][nu],
+                 outputChain[mu], hs.work.chainShift[nu],
+                 tm1, tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+    threadBarrier()
+
+template buildForwardPairStage(Stage: static int, hs, pairSrc, outX, outProj,
+                               ma, alp, tm1: untyped) =
+  when Stage == 1:
+    threads:
+      forPairs(mu, nu):
+        discard hs.state.gaugePairShift[mu][nu] ^*! hs.state.gf[mu]
+
+  threads:
+    forPairs(mu, nu):
+      outX[mu,nu] := ma * hs.state.gf[mu]
+      when Stage == 1:
+        symStaple(outX[mu,nu], alp, hs.state.gf[nu], hs.state.gf[mu],
+                  hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
+                  tm1, hs.state.sm1[nu])
+        threadBarrier()
+      else:
+        forThird(mu, nu, a, b):
+          let pl1 = pairSrc[a,b]
+          let pl2 = pairSrc[mu,b]
           threadBarrier()
-          discard s1[nu][mu] ^*! lp1
-          discard s1[mu][nu] ^*! lp2
+          discard hs.state.stagePairShift[nu][mu] ^*! pl1
+          discard hs.state.stagePairShift[mu][a] ^*! pl2
           threadBarrier()
-          symStaple(flx[mu], alp3, lp1, lp2,
-                    s1[nu][mu], s1[mu][nu], tm1, sm1[nu])
-      fl[mu].proj flx[mu]
-  toc("threads end")
-
-  proc smearedForce(f,chain:G) =
-    tic("smearedF")
-    # fₓₚₜ ← chainₘₖₕ d/dUₓₚₜ^*[Vₘₖₕ(U)^*] + chainₘₕₖ^* d/dUₓₚₜ^*[Vₘₕₖ(U)]
-    var
-      fl1 = newFieldArray2(lo,lcm,[4,4],mu!=nu)
-      fl2 = newOneOf(fl1)
-      fc = newFieldArray(lo,lcm,4)
-      fs: array[4,Shifter[lcm,type(gf[0][0])]]
-      tm2: lcm
-    tm2 = newlcm()
+          symStaple(outX[mu,nu], alp, pl1, pl2,
+                    hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
+                    tm1, hs.state.sm1[a])
+          threadBarrier()
+      outProj[mu,nu].proj outX[mu,nu]
+
+template buildTangentPairStage(Stage: static int, hs, pairSrc, tangentSrc,
+                               shiftedTangents, preProjOut, tangentOut,
+                               preProjBase, projBase, dgEff, ma, alp, tm1: untyped) =
+  when Stage == 1:
+    threads:
+      forPairs(mu, nu):
+        discard hs.state.gaugePairShift[mu][nu] ^*! hs.state.gf[mu]
+
+  threads:
+    forPairs(mu, nu):
+      preProjOut[mu,nu] := ma * dgEff[mu]
+      when Stage == 1:
+        symStapleJVP(preProjOut[mu,nu], alp,
+                     hs.state.gf[nu], hs.state.gf[mu],
+                     hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
+                     tangentSrc[nu], tangentSrc[mu],
+                     shiftedTangents[nu][mu], shiftedTangents[mu][nu],
+                     tm1, hs.state.sm1[nu])
+        threadBarrier()
+      else:
+        forThird(mu, nu, a, b):
+          let pl1 = pairSrc[a,b]
+          let pl2 = pairSrc[mu,b]
+          let dpl1 = tangentSrc[a,b]
+          let dpl2 = tangentSrc[mu,b]
+          threadBarrier()
+          discard hs.state.stagePairShift[nu][mu] ^*! pl1
+          discard hs.state.stagePairShift[mu][a] ^*! pl2
+          discard shiftedTangents[mu][nu][a][0] ^*! dpl1
+          discard shiftedTangents[mu][nu][a][1] ^*! dpl2
+          threadBarrier()
+          symStapleJVP(preProjOut[mu,nu], alp,
+                       pl1, pl2, hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
+                       dpl1, dpl2,
+                       shiftedTangents[mu][nu][a][0], shiftedTangents[mu][nu][a][1],
+                       tm1, hs.state.sm1[a])
+          threadBarrier()
+      tangentOut[mu,nu].projJVP(projBase[mu,nu], preProjBase[mu,nu], preProjOut[mu,nu])
+
+template applyReversePairStage(Stage: static int, hs, pairSrc, chainIn, dst,
+                               tm1, tm2: untyped) =
+  threads:
+    forPairs(mu, nu):
+      when Stage == 1:
+        discard hs.work.chainShift[nu] ^* chainIn[mu,nu]
+        symStapleVJP(dst[nu], dst[mu],
+                     hs.state.gf[nu], hs.state.gf[mu],
+                     hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
+                     chainIn[mu,nu], hs.work.chainShift[nu],
+                     tm1, tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+        threadBarrier()
+      else:
+        forThird(mu, nu, a, b):
+          let pl1 = pairSrc[a,b]
+          let pl2 = pairSrc[mu,b]
+          threadBarrier()
+          discard hs.state.stagePairShift[nu][mu] ^*! pl1
+          discard hs.state.stagePairShift[mu][a] ^*! pl2
+          discard hs.work.chainShift[a] ^*! chainIn[mu,nu]
+          threadBarrier()
+          symStapleVJP(dst[a,b], dst[mu,b],
+                       pl1, pl2,
+                       hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
+                       chainIn[mu,nu], hs.work.chainShift[a],
+                       tm1, tm2, hs.state.sm1[a], hs.state.sm1[mu])
+          threadBarrier()
+
+template applyReversePairStageChainAdjoint(Stage: static int, hs, pairSrc,
+                                           dst, seedBar, tm1, tm2: untyped) =
+  threads:
+    forPairs(mu, nu):
+      when Stage == 1:
+        symStapleVJPChain(dst[mu,nu],
+                          hs.state.gf[nu], hs.state.gf[mu],
+                          hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
+                          seedBar[nu], seedBar[mu],
+                          hs.work.chainShift[nu], hs.work.seedShift[mu],
+                          tm1, tm2, hs.state.sm1[nu])
+        threadBarrier()
+      else:
+        forThird(mu, nu, a, b):
+          let pl1 = pairSrc[a,b]
+          let pl2 = pairSrc[mu,b]
+          threadBarrier()
+          discard hs.state.stagePairShift[nu][mu] ^*! pl1
+          discard hs.state.stagePairShift[mu][a] ^*! pl2
+          threadBarrier()
+          symStapleVJPChain(dst[mu,nu],
+                            pl1, pl2,
+                            hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
+                            seedBar[a,b], seedBar[mu,b],
+                            hs.work.chainShift[a], hs.work.seedShift[mu],
+                            tm1, tm2, hs.state.sm1[a])
+          threadBarrier()
+
+template accumulateAndScaleGauge(dst, src, ma, alp: auto) =
+  threads:
+    for mu in 0..<4:
+      dst[mu] += ma * src[mu]
+      src[mu] *= alp
+
+template accumulateAndScalePairs(dst, src, ma, alp: auto) =
+  threads:
+    forPairs(mu, nu):
+      dst[mu] += ma * src[mu,nu]
+      src[mu,nu] *= alp
+
+template addScaledGauge(dst, src, scale: auto) =
+  threads:
     for mu in 0..<4:
-      fs[mu] = newShifter(fc[mu], mu, 1)
-    toc("prep")
+      dst[mu] += scale * src[mu]
 
+template addScaledPairs(dst, src, scale: auto) =
+  threads:
+    forPairs(mu, nu):
+      dst[mu,nu] += scale * src[mu,nu]
+
+template applyPairProjectionHvpPhase(chainBar, dChainBar, projected, xfield,
+                                     preProjChain, tangent, derivHvp,
+                                     ma, alp: untyped) =
+  applyProjectionHVP(chainBar, dChainBar, projected, xfield, preProjChain, tangent)
+  accumulateAndScalePairs(derivHvp, chainBar, ma, alp)
+
+template applyPairStapleHvpPhase(Stage: static int, hs, pairSrc, tangentSrc,
+                                 chainSrc, dChainIn, dst, tm1, tm2: untyped) =
+  block:
+    let lo = hs.state.gf[0].l
+    type Fld = typeof(hs.state.gf[0])
+    when Stage == 1:
+      var shiftedPairTangents: array[4, array[4, array[2, Shifter[Fld,type(hs.state.gf[0][0])]]]]
+      var shiftedChainTangents: array[4, array[4, Shifter[Fld,type(hs.state.gf[0][0])]]]
+      forPairs(mu, nu):
+        shiftedPairTangents[mu][nu][0] = newShifter(tangentSrc[nu], mu, 1)
+        shiftedPairTangents[mu][nu][1] = newShifter(tangentSrc[mu], nu, 1)
+        shiftedChainTangents[mu][nu] = newShifter(dChainIn[mu,nu], nu, 1)
+      var acc1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+      var acc2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+
+      threads:
+        forPairs(mu, nu):
+          discard hs.work.chainShift[nu] ^* chainSrc[mu,nu]
+          discard shiftedPairTangents[mu][nu][0] ^*! tangentSrc[nu]
+          discard shiftedPairTangents[mu][nu][1] ^*! tangentSrc[mu]
+          discard shiftedChainTangents[mu][nu] ^*! dChainIn[mu,nu]
+          symStapleHVP(dst[nu], dst[mu], acc1[mu,nu], acc2[mu,nu],
+                       hs.state.gf[nu], hs.state.gf[mu],
+                       hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
+                       chainSrc[mu,nu], hs.work.chainShift[nu],
+                       tangentSrc[nu], tangentSrc[mu], dChainIn[mu,nu],
+                       shiftedPairTangents[mu][nu][0], shiftedPairTangents[mu][nu][1],
+                       shiftedChainTangents[mu][nu],
+                       tm1, tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+          threadBarrier()
+    else:
+      var shiftedPairTangents: array[4, array[4, array[4, array[2, Shifter[Fld,type(hs.state.gf[0][0])]]]]]
+      var shiftedChainTangents: array[4, array[4, array[4, Shifter[Fld,type(hs.state.gf[0][0])]]]]
+      forPairs(mu, nu):
+        forThird(mu, nu, a, b):
+          shiftedPairTangents[mu][nu][a][0] = newShifter(tangentSrc[a,b], mu, 1)
+          shiftedPairTangents[mu][nu][a][1] = newShifter(tangentSrc[mu,b], a, 1)
+          shiftedChainTangents[mu][nu][a] = newShifter(dChainIn[mu,nu], a, 1)
+      var acc1: array[4, array[4, array[4, Fld]]]
+      var acc2: array[4, array[4, array[4, Fld]]]
+      forPairs(mu, nu):
+        forThird(mu, nu, a, b):
+          acc1[mu][nu][a] = lo.newField(type(hs.state.gf[0][0]))
+          acc2[mu][nu][a] = lo.newField(type(hs.state.gf[0][0]))
+
+      threads:
+        forPairs(mu, nu):
+          forThird(mu, nu, a, b):
+            let pl1 = pairSrc[a,b]
+            let pl2 = pairSrc[mu,b]
+            threadBarrier()
+            discard hs.state.stagePairShift[nu][mu] ^*! pl1
+            discard hs.state.stagePairShift[mu][a] ^*! pl2
+            discard hs.work.chainShift[a] ^*! chainSrc[mu,nu]
+            discard shiftedPairTangents[mu][nu][a][0] ^*! tangentSrc[a,b]
+            discard shiftedPairTangents[mu][nu][a][1] ^*! tangentSrc[mu,b]
+            discard shiftedChainTangents[mu][nu][a] ^*! dChainIn[mu,nu]
+            threadBarrier()
+            symStapleHVP(dst[a,b], dst[mu,b],
+                         acc1[mu][nu][a], acc2[mu][nu][a],
+                         pl1, pl2,
+                         hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
+                         chainSrc[mu,nu], hs.work.chainShift[a],
+                         tangentSrc[a,b], tangentSrc[mu,b], dChainIn[mu,nu],
+                         shiftedPairTangents[mu][nu][a][0], shiftedPairTangents[mu][nu][a][1],
+                         shiftedChainTangents[mu][nu][a],
+                         tm1, tm2, hs.state.sm1[a], hs.state.sm1[mu])
+            threadBarrier()
+
+template backpropPairHvpOutputPhase(Stage: static int, hs, pairSrc, chainSrc,
+                                    seedBar, pairBarOut, chainBar,
+                                    nextChainBar, projected, xfield,
+                                    preProjChain, alp, tm1, tm2: untyped) =
+  block:
+    let lo = hs.state.gf[0].l
+    type Fld = typeof(hs.state.gf[0])
+    var dcbar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
     threads:
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            fl1[mu,nu] := 0
-            fl2[mu,nu] := 0
+      forPairs(mu, nu):
+        dcbar[mu,nu] := 0
 
-      # proj flx → fl, fc ← chain
-      for mu in 0..<4:
-        fc[mu].projDeriv(flx[mu], chain[mu])
-      # link (gf, l2) → flx, (f, fl2) ← fc
-      for mu in 0..<4:
-        f[mu] := ma3 * fc[mu]
-        fc[mu] *= alp3
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            when keepProj:
-              template lp1:untyped = l2[nu,mu]
-              template lp2:untyped = l2[mu,nu]
-            else:
-              lp1.proj l2x[nu,mu]
-              lp2.proj l2x[mu,nu]
+    threads:
+      forPairs(mu, nu):
+        when Stage == 1:
+          discard hs.work.chainShift[nu] ^* chainSrc[mu,nu]
+          symStapleHVPVJP(pairBarOut[nu], pairBarOut[mu], dcbar[mu,nu],
+                          hs.state.gf[nu], hs.state.gf[mu],
+                          hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
+                          chainSrc[mu,nu], hs.work.chainShift[nu],
+                          seedBar[nu], seedBar[mu],
+                          hs.work.seedShift[nu], hs.work.seedShift[mu],
+                          tm1, tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+          threadBarrier()
+        else:
+          forThird(mu, nu, a, b):
+            let pl1 = pairSrc[a,b]
+            let pl2 = pairSrc[mu,b]
+            threadBarrier()
+            discard hs.state.stagePairShift[nu][mu] ^*! pl1
+            discard hs.state.stagePairShift[mu][a] ^*! pl2
+            discard hs.work.chainShift[a] ^*! chainSrc[mu,nu]
             threadBarrier()
-            discard s1[nu][mu] ^*! lp1
-            discard s1[mu][nu] ^*! lp2
-            discard fs[nu] ^*! fc[mu]
+            symStapleHVPVJP(pairBarOut[a,b], pairBarOut[mu,b], dcbar[mu,nu],
+                            pl1, pl2,
+                            hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
+                            chainSrc[mu,nu], hs.work.chainShift[a],
+                            seedBar[a,b], seedBar[mu,b],
+                            hs.work.seedShift[a], hs.work.seedShift[mu],
+                            tm1, tm2, hs.state.sm1[a], hs.state.sm1[mu])
             threadBarrier()
-            symStapleDeriv(fl2[nu,mu], fl2[mu,nu],
-                           lp1, lp2, s1[nu][mu], s1[mu][nu],
-                           fc[mu], fs[nu], tm1, tm2, sm1[nu], sm1[mu])
-      toc("1")
 
-      # proj l2x → l2, fl2 ← fl2
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            when keepProj:
-              fl2[mu,nu].projDeriv(l2[mu,nu], l2x[mu,nu], fl2[mu,nu])
-            else:
-              fl2[mu,nu].projDeriv(l2x[mu,nu], fl2[mu,nu])
-      # link (gf, l1) → l2x, (f, fl1) ← fl2
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            f[mu] += ma2 * fl2[mu,nu]
-            fl2[mu,nu] *= alp2
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            for a in 0..<4:
-              if a!=mu and a!=nu:
-                let b = 1+2+3-mu-nu-a
-                when keepProj:
-                  template lp1:untyped = l1[a,b]
-                  template lp2:untyped = l1[mu,b]
-                else:
-                  lp1.proj l1x[a,b]
-                  lp2.proj l1x[mu,b]
-                threadBarrier()
-                discard s1[nu][mu] ^*! lp1
-                discard s1[mu][a] ^*! lp2
-                discard fs[a] ^*! fl2[mu,nu]
-                threadBarrier()
-                symStapleDeriv(fl1[a,b], fl1[mu,b],
-                               lp1, lp2, s1[nu][mu], s1[mu][a],
-                               fl2[mu,nu], fs[a], tm1, tm2, sm1[a], sm1[mu])
-      toc("2")
-
-      # proj l1x → l1, fl1 ← fl1
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            when keepProj:
-              fl1[mu,nu].projDeriv(l1[mu,nu], l1x[mu,nu], fl1[mu,nu])
-            else:
-              fl1[mu,nu].projDeriv(l1x[mu,nu], fl1[mu,nu])
-            discard s1[mu][nu] ^*! gf[mu]
-      # link gf → l1, f ← fl1
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            f[mu] += ma1 * fl1[mu,nu]
-            fl1[mu,nu] *= alp1
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            discard fs[nu] ^* fl1[mu,nu]
-            symStapleDeriv(f[nu], f[mu],
-                           gf[nu], gf[mu], s1[nu][mu], s1[mu][nu],
-                           fl1[mu,nu], fs[nu], tm1, tm2, sm1[nu], sm1[mu])
-    toc("end")
-
-  toc("end")
-  smearedForce
+    addScaledPairs(chainBar, dcbar, alp)
 
-proc smearPriv[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) {.codegenDecl:
-    "__attribute__((noinline)) $# $#$#".} =
-  # Avoid inlining or other compiler optimizations
-  # in order to guarantee the change of the stack pointer,
-  # such that Nim's GC is able to collect the memory.
-  {.emit: "asm (\"\");".}
-  var f = coef.smearGetForce(gf, fl, info)
-  f = nil
-proc smear*[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) =
-  ## Try our best to release memory here.
-  ## Sometimes it still requires a GC after this function returns.
-  coef.smearPriv(gf, fl, info)
-  qexGC()
+    threads:
+      forPairs(mu, nu):
+        nextChainBar[mu,nu].projHVPVJP_dc(
+          projected[mu,nu], xfield[mu,nu], preProjChain[mu,nu],
+          chainBar[mu,nu]
+        )
 
-#proc smear*(c: HypCoefs, gf: auto, fl: auto, info: var PerfInfo) =
-#  var t = newHypTemps(gf)
-#  smear(c, gf, fl, t, info)
+template backpropPairTangentPhase(Stage: static int, hs, pairSrc, tangentXBar,
+                                  pairBarOut, dgEffbar, ma, alp, tm1, tm2: untyped) =
+  threads:
+    forPairs(mu, nu):
+      dgEffbar[mu] += ma * tangentXBar[mu,nu]
 
-proc smear*(c: HypCoefs, g: auto, fl: auto) =
-  var info: PerfInfo
-  c.smear(g, fl, info)
+  threads:
+    forPairs(mu, nu):
+      when Stage == 1:
+        symStapleJVPVJP(dgEffbar[nu], dgEffbar[mu], alp,
+                        hs.state.gf[nu], hs.state.gf[mu],
+                        hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
+                        tangentXBar[mu,nu], hs.work.seedShift[nu],
+                        tm1, tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+        threadBarrier()
+      else:
+        forThird(mu, nu, a, b):
+          let pl1 = pairSrc[a,b]
+          let pl2 = pairSrc[mu,b]
+          threadBarrier()
+          discard hs.state.stagePairShift[nu][mu] ^*! pl1
+          discard hs.state.stagePairShift[mu][a] ^*! pl2
+          threadBarrier()
+          symStapleJVPVJP(pairBarOut[a,b], pairBarOut[mu,b], alp,
+                          pl1, pl2,
+                          hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
+                          tangentXBar[mu,nu], hs.work.seedShift[a],
+                          tm1, tm2, hs.state.sm1[a], hs.state.sm1[mu])
+          threadBarrier()
 
-# (d/dX') < C' F + F' C > /2
-proc deriv*(coef: HypCoefs, gf: auto, fl: auto, info: var PerfInfo) =
-  tic()
-  type lcm = type(gf[0])
-  proc newlcm: lcm = result.new(gf[0].l)
-  var
-    l1: array[4,array[4,lcm]]
-    l2: array[4,array[4,lcm]]
-    tm1: lcm
-    sm1: array[4,Shifter[lcm,type(gf[0][0])]]
-    s1: array[4,array[4,Shifter[lcm,type(gf[0][0])]]]
-    nflop = 61632.0
-    dtime = 0.0
-
-  tm1 = newlcm()
-  for mu in 0..<4:
-    sm1[mu] = newShifter(gf[mu], mu, -1)
-    for nu in 0..<4:
-      if nu!=mu:
-        l1[mu][nu] = newlcm()
-        l2[mu][nu] = newlcm()
-        s1[mu][nu] = newShifter(gf[mu], nu, 1)
-        discard s1[mu][nu] ^* gf[mu]
+proc buildTangentState[L,F,T](hs: var HypSmear[L,F,T], dg: auto): auto =
+  ## Build the shared forward tangent state used by `smearJVP` and `smearHVP`.
+  let sc = hs.scaleFactors
+  var l1: type(hs.state.l1x)
+  var l2: type(hs.state.l2x)
+  initProjectedLevels(hs, l1, l2)
+  let hsp = hs.addr
 
-  let alp1 = coef.alpha1 / 2.0
-  for mu in 0..<4:
-    #fl[mu] := 0
-    for nu in 0..<4:
-      if nu!=mu:
-        l1[mu][nu] := (1-coef.alpha1) * gf[mu]
-        symStaple(l1[mu][nu], alp1, gf[nu], gf[mu],
-                  s1[nu][mu], s1[mu][nu], tm1, sm1[nu])
-        proj l1[mu][nu]
-        #fl[mu] += l1[mu][nu]
-
-  let alp2 = coef.alpha2 / 4.0
-  for mu in 0..<4:
-    #fl[mu] := 0
-    for nu in 0..<4:
-      if nu!=mu:
-        l2[mu][nu] := (1-coef.alpha2) * gf[mu]
-        for a in 0..<4:
-          if a!=mu and a!=nu:
-            let b = 1+2+3-mu-nu-a
-            discard s1[nu][mu] ^* l1[a][b]
-            discard s1[mu][a] ^* l1[mu][b]
-            symStaple(l2[mu][nu], alp2, l1[a][b], l1[mu][b],
-                      s1[nu][mu], s1[mu][a], tm1, sm1[a])
-        proj l2[mu][nu]
-        #fl[mu] += l1[mu][nu]
-
-  let alp3 = coef.alpha3 / 6.0
+  let lo = hs.state.gf[0].l
+  type Fld = typeof(hs.state.gf[0])
+  let dgEff = buildGaugeTangent(hs.state.gf, dg)
+  let ds1 = initShiftedTangents(dgEff)
+
+  var dl1x = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dl2x = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dflx = newFieldArray(lo, Fld, 4)
+  var dl1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  var dl2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+
+  clearTangentWorkspace(dflx, dl1x, dl2x, dl1, dl2)
+
+  buildTangentPairStage(1, hsp, l1, dgEff, ds1, dl1x, dl1, hsp.state.l1x, l1, dgEff, sc.ma1, sc.alp1, hsp.work.tm1)
+
+  var dsl1_l2: array[4, array[4, array[4, array[2, Shifter[Fld,type(hs.state.gf[0][0])]]]]]
+  forPairs(mu, nu):
+    forThird(mu, nu, a, b):
+      dsl1_l2[mu][nu][a][0] = newShifter(dl1[a,b], mu, 1)
+      dsl1_l2[mu][nu][a][1] = newShifter(dl1[mu,b], a, 1)
+
+  buildTangentPairStage(2, hsp, l1, dl1, dsl1_l2, dl2x, dl2, hsp.state.l2x, l2, dgEff, sc.ma2, sc.alp2, hsp.work.tm1)
+
+  var dsl2: array[4,array[4,Shifter[Fld,type(hs.state.gf[0][0])]]]
+  forPairs(mu, nu):
+    dsl2[mu][nu] = newShifter(dl2[mu,nu], nu, 1)
+  threads:
+    forPairs(mu, nu):
+      discard dsl2[mu][nu] ^*! dl2[mu,nu]
+      discard hsp.state.stagePairShift[mu][nu] ^*! l2[mu,nu]
+
+  threads:
+    for mu in 0..<4:
+      dflx[mu] := sc.ma3 * dgEff[mu]
+      forNu(mu, nu):
+        let pl1 = l2[nu,mu]
+        let pl2 = l2[mu,nu]
+        let dpl1 = dl2[nu,mu]
+        let dpl2 = dl2[mu,nu]
+        symStapleJVP(dflx[mu], sc.alp3,
+                        pl1, pl2, hsp.state.stagePairShift[nu][mu], hsp.state.stagePairShift[mu][nu],
+                        dpl1, dpl2, dsl2[nu][mu], dsl2[mu][nu],
+                        hsp.work.tm1, hsp.state.sm1[nu])
+        threadBarrier()
+
+  HypTangentState[typeof(dgEff), typeof(dflx), typeof(dl1x), typeof(dsl2)](
+    dgEff: dgEff,
+    dl1x: dl1x,
+    dl1: dl1,
+    dl2x: dl2x,
+    dl2: dl2,
+    dflx: dflx,
+    dsl2: dsl2,
+  )
+
+template accumulateProjectionAdjoint(dxbar, x, chain0, tangentBar, hvpBar: auto) =
+  threads:
+    forPairs(mu, nu):
+      var tmp {.noinit.}: type(dxbar[mu,nu][0])
+      for i in dxbar[mu,nu]:
+        tmp.projectUVJP(x[mu,nu][i], tangentBar[mu,nu][i])
+        dxbar[mu,nu][i] := tmp
+
+  threads:
+    forPairs(mu, nu):
+      var tmp {.noinit.}: type(dxbar[mu,nu][0])
+      for i in dxbar[mu,nu]:
+        tmp.projectUHVPVJP_dx(x[mu,nu][i], chain0[mu,nu][i], hvpBar[mu,nu][i])
+        dxbar[mu,nu][i] += tmp
+
+template applyPairProjectionChainAdjoint(chainBar, projected, xfield: auto) =
+  let lo = projected[0,1].l
+  type Fld = typeof(projected[0,1])
+  var chainBarTmp = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  threads:
+    forPairs(mu, nu):
+      chainBarTmp[mu,nu] := chainBar[mu,nu]
+      chainBar[mu,nu] := 0
+      chainBar[mu,nu].projVJPChain(projected[mu,nu], xfield[mu,nu], chainBarTmp[mu,nu])
+
+template applyProjectionHVP(dst, dchain0, u, x, chain0, dx: auto) =
+  ## Apply the projection HVP for a full level while preserving the incoming
+  ## chain tangent in `dchain0`.
+  threads:
+    forPairs(mu, nu):
+      dchain0[mu,nu] := dst[mu,nu]
+      dst[mu,nu] := 0
+      dst[mu,nu].projHVPu(u[mu,nu], x[mu,nu], chain0[mu,nu],
+                          dx[mu,nu], dchain0[mu,nu])
+
+template applyOutputProjectionHVP(dst, x, chain0, dx, dchain: auto) =
+  threads:
+    for mu in 0..<4:
+      if dchain.len > 0:
+        dst[mu].projHVP(x[mu], chain0[mu], dx[mu], dchain[mu])
+      else:
+        dst[mu].projHVP(x[mu], chain0[mu], dx[mu])
+
+template seedSmearHVPAdjoints(dfl1bar, dfl2bar, dfcbar, derivbar,
+                              ma1, ma2, ma3: auto) =
+  threads:
+    for mu in 0..<4:
+      dfcbar[mu] += ma3 * derivbar[mu]
+      forNu(mu, nu):
+        dfl1bar[mu,nu] += ma1 * derivbar[mu]
+        dfl2bar[mu,nu] += ma2 * derivbar[mu]
+
+template buildReverseState(hsp, chain, deriv: untyped; accumulateDirect: static bool) =
+  ## Build the reverse HYP chain state, optionally accumulating the direct
+  ## ma3/ma2/ma1 contributions into `deriv`.
+  let sc = hsp[].scaleFactors
+  var l1: type(hsp.state.l1x)
+  var l2: type(hsp.state.l2x)
+  initProjectedLevels(hsp[], l1, l2)
+
+  clearReverseChains(hsp.work.outputChain, hsp.work.level1Chain, hsp.work.level2Chain)
+
+  threads:
+    for mu in 0..<4:
+      hsp.work.outputChain[mu].projVJP(hsp.state.flx[mu], chain[mu])
+      when accumulateDirect:
+        deriv[mu] := sc.ma3 * hsp.work.outputChain[mu]
+      hsp.work.outputChain[mu] *= sc.alp3
+
+  buildLevel3ReverseChains(hsp, l2, hsp.work.outputChain, hsp.work.level2Chain,
+                           hsp.work.tm1, hsp.work.tm2)
+  projectAndScalePairChain(hsp.work.level2Chain, l2, hsp.state.l2x,
+                           hsp.work.preProjLevel2Chain, sc.alp2, deriv, sc.ma2,
+                           accumulateDirect)
+  applyReversePairStage(2, hsp, l1, hsp.work.level2Chain, hsp.work.level1Chain,
+                        hsp.work.tm1, hsp.work.tm2)
+  projectAndScalePairChain(hsp.work.level1Chain, l1, hsp.state.l1x,
+                           hsp.work.preProjLevel1Chain, sc.alp1, deriv, sc.ma1,
+                           accumulateDirect)
+
+proc smear*(hs: var HypSmear, gf: auto, fl: auto) =
+  static: doAssert(type(gf[0]) is typeof(hs.state.gf[0]))
+  ## Apply HYP smearing; intermediates stored in hs for derivative
+  let sc = hs.scaleFactors
   for mu in 0..<4:
-    fl[mu] := (1-coef.alpha3) * gf[mu]
-    for nu in 0..<4:
-      if nu!=mu:
-        discard s1[nu][mu] ^* l2[nu][mu]
-        discard s1[mu][nu] ^* l2[mu][nu]
-        symStaple(fl[mu], alp3, l2[nu][mu], l2[mu][nu],
-                  s1[nu][mu], s1[mu][nu], tm1, sm1[nu])
-    proj fl[mu]
-
-  toc()
-
-#proc deriv*(c: HypCoefs, g: auto, fl: auto) =
-#  var info: PerfInfo
-#  c.deriv(g, fl, info)
-
-when isMainModule:
-  import qex
-  qexInit()
-  #var defaultGaugeFile = "l88.scidac"
-  let defaultLat = @[8,8,8,8]
-  defaultSetup()
-  #for mu in 0..<g.len: g[mu] := 1
-  #g.random
+    hs.state.gf[mu] = gf[mu]
+  var
+    cachedGauge = hs.state.gf
+    l1x = hs.state.l1x
+    l2x = hs.state.l2x
+    flx = hs.state.flx
+    tm1 = hs.work.tm1
+  var l1: typeof(l1x)
+  var l2: typeof(l2x)
+  initForwardProjectedLevels(hs, l1, l2)
+  let hsp = hs.addr
 
-  var info: PerfInfo
-  var coef: HypCoefs
-  coef.alpha1 = 0.4
-  coef.alpha2 = 0.5
-  coef.alpha3 = 0.5
-
-  echo coef
-
-  var fl = lo.newGauge()
-  coef.smear(g, fl, info)
-  resetTimers()
-
-  template disp(g: typed) =
-    let p = g.plaq
-    let sp = 2.0*(p[0]+p[1]+p[2])
-    let tp = 2.0*(p[3]+p[4]+p[5])
-    echo p
-    echo sp
-    echo tp
-    echo trace(g[0])
-
-  disp g
-  tic("main")
-  coef.smear(g, fl, info)
-  toc("smear")
-  disp fl
-  #echo pow(1.0,4)/6.0
-  #echo pow(1.0+6.0,4)/6.0
-  #echo pow(1.0+6.0+6.0*4.0,4)/6.0
-  #echo pow(1.0+6.0+6.0*4.0+6.0*4.0*2.0,4)/6.0
-  #echo pow(1.0+6.0+6.0*4.0+6.0*4.0*2.0+6.0,4)/6.0
-
-  echoTimers()
-  qexFinalize()
+  buildForwardPairStage(1, hsp, l1, l1x, l1, sc.ma1, sc.alp1, tm1)
+  buildForwardPairStage(2, hsp, l1, l2x, l2, sc.ma2, sc.alp2, tm1)
+  threads:
+    forPairs(mu, nu):
+      discard hsp.state.stagePairShift[mu][nu] ^*! l2[mu,nu]
+  threads:
+    for mu in 0..<4:
+      flx[mu] := sc.ma3 * cachedGauge[mu]
+      forNu(mu, nu):
+        let pl1 = l2[nu,mu]
+        let pl2 = l2[mu,nu]
+        symStaple(flx[mu], sc.alp3, pl1, pl2,
+                  hsp.state.stagePairShift[nu][mu], hsp.state.stagePairShift[mu][nu],
+                  tm1, hsp.state.sm1[nu])
+        threadBarrier()
+      fl[mu].proj flx[mu]
+
+proc smearVJP*(hs: var HypSmear, deriv: auto, chain: auto) =
+  static:
+    doAssert(type(deriv[0]) is typeof(hs.state.gf[0]))
+    doAssert(type(chain[0]) is typeof(hs.state.gf[0]))
+  ## Backpropagate derivative through hs.smear
+  let hsp = hs.addr
+  buildReverseState(hsp, chain, deriv, true)
+  applyReversePairStage(1, hsp, hsp.work.level1Chain, hsp.work.level1Chain,
+                        deriv, hsp.work.tm1, hsp.work.tm2)
+
+template applyOutputProjectionJvp(dst, projected, preProj, tangent: auto) =
+  let lo = preProj[0].l
+  var tangentTmp = lo.newGauge
+  threads:
+    for mu in 0..<4:
+      tangentTmp[mu] := tangent[mu]
+      dst[mu].projJVP(projected[mu], preProj[mu], tangentTmp[mu])
+
+proc smearJVP*[G](hs: var HypSmear, dsg: G, dg: G, sg: G) =
+  ## Forward tangent of HYP smearing.
+  ##
+  ## Computes: dsg = d/dε|_{ε=0} [ HYP(exp(ε dg) g) ]
+  ##
+  ## Under multiplicative perturbation exp(ε·dg)·gf, this computes the
+  ## tangent of the projected smeared output field.
+  ##
+  ## Parameters:
+  ##   dsg: output - the tangent of the smeared field (projected)
+  ##   dg:  input  - the Lie algebra perturbation direction
+  ##   sg:  input  - the projected smeared field from hs.smear(g, sg)
+  ##
+  ## NOTE: hs.smear(g, sg) must be called first to populate internal state.
+  static:
+    doAssert(type(dsg[0]) is typeof(hs.state.gf[0]))
+    doAssert(type(dg[0])  is typeof(hs.state.gf[0]))
+  let hsp = hs.addr
+  let tangents = hs.buildTangentState(dg)
+
+  applyOutputProjectionJvp(dsg, sg, hsp.state.flx, tangents.dflx)
+
+template applyLevel3StapleHvpPhase(hs, dLevel2Chain, l2, dl2, dsl2,
+                                   dOutputChain: untyped) =
+  block:
+    var scratch = newLevel3HvpScratch(hs.state.gf, dOutputChain)
+
+    forLevel3Pairs(hs, l2, pl1, pl2):
+        discard hs.work.chainShift[nu] ^*! hs.work.outputChain[mu]
+        discard scratch.shiftedOutputChain[mu][nu] ^*! dOutputChain[mu]
+        threadBarrier()
+        symStapleHVP(dLevel2Chain[nu,mu], dLevel2Chain[mu,nu],
+                     scratch.acc1[mu,nu], scratch.acc2[mu,nu],
+                     pl1, pl2, hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][nu],
+                     hs.work.outputChain[mu], hs.work.chainShift[nu],
+                     dl2[nu,mu], dl2[mu,nu], dOutputChain[mu],
+                     dsl2[nu][mu], dsl2[mu][nu], scratch.shiftedOutputChain[mu][nu],
+                     hs.work.tm1, hs.work.tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+        threadBarrier()
+
+proc smearHVP*[G](hs: var HypSmear, dderiv: G, chain: G, dg: G,
+                  dchain: G = @[]) =
+  ## Second derivative of the uncontracted HYP reverse pass.
+  ##
+  ## Computes: dderiv = d/dε|_{ε=0} [ smearVJP(exp(ε dg) g, chain + ε dchain) ]
+  ##
+  ## When dchain is provided, this includes the variation of the chain field,
+  ## enabling full chain rule computation for T(U) = <p, smearVJP(U, gaugeActionDeriv(HYP(U)))>.
+  ##
+  ## This is the pure forward-over-reverse Hessian–vector product for the HYP
+  ## smear. Any outer contraction, such as contractProjectTAH(g, ·), is handled
+  ## by the caller instead of being mixed into this API.
+  static:
+    doAssert(type(dderiv[0]) is typeof(hs.state.gf[0]))
+    doAssert(type(chain[0])  is typeof(hs.state.gf[0]))
+    doAssert(type(dg[0])     is typeof(hs.state.gf[0]))
+
+  let sc = hs.scaleFactors
+  var l1: type(hs.state.l1x)
+  var l2: type(hs.state.l2x)
+  initProjectedLevels(hs, l1, l2)
+  let hsp = hs.addr
+
+  ## Phase 1: analytical forward tangents
+  let tangents = hs.buildTangentState(dg)
+  let dgEff = tangents.dgEff
+  let dl1x = tangents.dl1x
+  let dl1 = tangents.dl1
+  let dl2x = tangents.dl2x
+  let dl2 = tangents.dl2
+  let dflx = tangents.dflx
+  let dsl2 = tangents.dsl2
+
+  var work = newHvpWorkspace(hs.state.gf)
+  clearHvpWorkspace(dderiv, work.dOutputChain, work.dLevel1Chain, work.dLevel2Chain)
+
+  ## Phase 2: shared reverse-chain state
+  buildReverseState(hsp, chain, nil, false)
+
+  ## Phase 3: second-order adjoints through the three HYP levels
+  applyOutputProjectionHVP(work.dOutputChain, hsp.state.flx, chain, dflx, dchain)
+  accumulateAndScaleGauge(dderiv, work.dOutputChain, sc.ma3, sc.alp3)
+  applyLevel3StapleHvpPhase(hsp, work.dLevel2Chain, l2, dl2, dsl2, work.dOutputChain)
+
+  # Level 2: projection on l2x and staples built from l1
+  applyPairProjectionHvpPhase(work.dLevel2Chain, work.dPreProjLevel2Chain, l2, hsp.state.l2x,
+                              hsp.work.preProjLevel2Chain, dl2x, dderiv, sc.ma2, sc.alp2)
+  applyPairStapleHvpPhase(2, hsp, l1, dl1, hsp.work.level2Chain, work.dLevel2Chain,
+                          work.dLevel1Chain, hsp.work.tm1, hsp.work.tm2)
+
+  # Level 1: projection on l1x and staples built directly from gf
+  applyPairProjectionHvpPhase(work.dLevel1Chain, work.dPreProjLevel1Chain, l1, hsp.state.l1x,
+                              hsp.work.preProjLevel1Chain, dl1x, dderiv, sc.ma1, sc.alp1)
+  applyPairStapleHvpPhase(1, hsp, dgEff, dgEff, hsp.work.level1Chain, work.dLevel1Chain,
+                          dderiv, hsp.work.tm1, hsp.work.tm2)
+
+proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
+  ## Adjoint of `smearVJP` with respect to `chain`.
+  ## Computes `chainbar` such that:
+  ##   ⟨derivbar, smearVJP(g, chain)⟩ = ⟨chainbar, chain⟩
+  ## using the cached forward HYP state and the reverse-chain phases in reverse order.
+  static:
+    doAssert(type(chainbar[0]) is typeof(hs.state.gf[0]))
+    doAssert(type(derivbar[0]) is typeof(hs.state.gf[0]))
+
+  let sc = hs.scaleFactors
+  var l1: type(hs.state.l1x)
+  var l2: type(hs.state.l2x)
+  initProjectedLevels(hs, l1, l2)
+  let hsp = hs.addr
+
+  # Phase 1: seed the adjoint workspaces
+  var work = newChainAdjointWorkspace(chainbar, hsp.state.gf)
+
+  # Phase 2: backpropagate the Level 1 reverse pair stage
+  applyReversePairStageChainAdjoint(1, hsp, l1, work.level1ChainBar, derivbar, hsp.work.tm1, hsp.work.tm2)
+
+  # Phase 3: apply the Level 1 direct term and projection-chain adjoint
+  threads:
+    forPairs(mu, nu):
+      work.level1ChainBar[mu,nu] *= sc.alp1
+      work.level1ChainBar[mu,nu] += sc.ma1 * derivbar[mu]
+  applyPairProjectionChainAdjoint(work.level1ChainBar, l1, hsp.state.l1x)
+
+  # Phase 4: backpropagate the Level 2 reverse pair stage
+  applyReversePairStageChainAdjoint(2, hsp, l1, work.level2ChainBar, work.level1ChainBar, hsp.work.tm1, hsp.work.tm2)
+
+  # Phase 5: apply the Level 2 direct term and projection-chain adjoint
+  threads:
+    forPairs(mu, nu):
+      work.level2ChainBar[mu,nu] *= sc.alp2
+      work.level2ChainBar[mu,nu] += sc.ma2 * derivbar[mu]
+  applyPairProjectionChainAdjoint(work.level2ChainBar, l2, hsp.state.l2x)
+
+  # Phase 6: backpropagate the Level 3 reverse pair stage
+  forLevel3Pairs(hsp, l2, pl1, pl2):
+    symStapleVJPChain(work.outputChainBar[mu],
+                      pl1, pl2, hsp.state.stagePairShift[nu][mu], hsp.state.stagePairShift[mu][nu],
+                      work.level2ChainBar[nu,mu], work.level2ChainBar[mu,nu],
+                      hsp.work.chainShift[nu], hsp.work.seedShift[mu],
+                      hsp.work.tm1, hsp.work.tm2, hsp.state.sm1[nu])
+    threadBarrier()
+
+  # Phase 7: apply the Level 3 direct term and finish at the output projection
+  threads:
+    for mu in 0..<4:
+      work.outputChainBar[mu] *= sc.alp3
+      work.outputChainBar[mu] += sc.ma3 * derivbar[mu]
+  threads:
+    for mu in 0..<4:
+      chainbar[mu].projVJPChain(hsp.state.flx[mu], work.outputChainBar[mu])
+
+template backpropLevel3HvpOutputPhase(hs, dl2bar, dOutputChainBar,
+                                      dLevel2ChainBarFromL3, l2, alp: untyped) =
+  block:
+    var scratch = newLevel3AdjointScratch(hs.state.gf)
+
+    forLevel3Pairs(hs, l2, pl1, pl2):
+      discard hs.work.chainShift[nu] ^*! hs.work.outputChain[mu]
+      threadBarrier()
+      symStapleHVPVJP(dl2bar[nu,mu], dl2bar[mu,nu], scratch.dcbar[mu],
+                      pl1, pl2, hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][nu],
+                      hs.work.outputChain[mu], hs.work.chainShift[nu],
+                      dLevel2ChainBarFromL3[nu,mu], dLevel2ChainBarFromL3[mu,nu],
+                      hs.work.seedShift[nu], hs.work.seedShift[mu],
+                      hs.work.tm1, hs.work.tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+      threadBarrier()
+
+    addScaledGauge(dOutputChainBar, scratch.dcbar, alp)
+
+template backpropLevel3TangentPhase(hs, dgEffbar, dl2bar, dOutputTangentBar,
+                                    l2, ma, alp: untyped) =
+  block:
+    threads:
+      for mu in 0..<4:
+        dgEffbar[mu] += ma * dOutputTangentBar[mu]
+
+    forLevel3Pairs(hs, l2, pl1, pl2):
+      symStapleJVPVJP(dl2bar[nu,mu], dl2bar[mu,nu], alp,
+                      pl1, pl2, hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][nu],
+                      dOutputTangentBar[mu], hs.work.seedShift[nu],
+                      hs.work.tm1, hs.work.tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+      threadBarrier()
+
+proc smearHVPVJP*[G](hs: var HypSmear, gbar: G, derivbar: G, chain: G) =
+  ## Adjoint of the `dg` branch of `smearHVP`.
+  ## Computes `gbar` such that:
+  ##   <derivbar, smearHVP(dg, dchain=0)> = <gbar, dg*g>
+  ## with the upstream chain held fixed. This reverses the forward-over-reverse
+  ## HVP path, including the dependence of the cached HYP state on the gauge field.
+  static:
+    doAssert(type(gbar[0]) is typeof(hs.state.gf[0]))
+    doAssert(type(derivbar[0]) is typeof(hs.state.gf[0]))
+    doAssert(type(chain[0]) is typeof(hs.state.gf[0]))
+
+  let sc = hs.scaleFactors
+  var l1: type(hs.state.l1x)
+  var l2: type(hs.state.l2x)
+  initProjectedLevels(hs, l1, l2)
+  let hsp = hs.addr
+  buildReverseState(hsp, chain, nil, false)
+
+  var work = newHvpAdjointWorkspace(gbar, hsp.state.gf)
+
+  # Phase 1: seed the adjoints from the output contribution of `smearHVP`
+  seedSmearHVPAdjoints(work.dfl1bar, work.dfl2bar, work.dfcbar, derivbar, sc.ma1, sc.ma2, sc.ma3)
+
+  # Phase 2: reverse the Level 1 and Level 2 HVP output paths
+  backpropPairHvpOutputPhase(1, hsp, l1, hsp.work.level1Chain, derivbar, work.dgEffbar,
+                             work.dfl1bar, work.dfl1barL2,
+                             l1, hsp.state.l1x, hsp.work.preProjLevel1Chain, sc.alp1,
+                             hsp.work.tm1, hsp.work.tm2)
+
+  backpropPairHvpOutputPhase(2, hsp, l1, hsp.work.level2Chain, work.dfl1barL2,
+                             work.dl1bar, work.dfl2bar, work.dfl2barL3,
+                             l2, hsp.state.l2x, hsp.work.preProjLevel2Chain, sc.alp2,
+                             hsp.work.tm1, hsp.work.tm2)
+
+  # Phase 3: reverse the Level 3 HVP output path back into the tangent state
+  backpropLevel3HvpOutputPhase(hsp, work.dl2bar, work.dfcbar, work.dfl2barL3, l2, sc.alp3)
+  threads:
+    for mu in 0..<4:
+      work.dflxbar[mu].projHVPVJP_dx(hsp.state.flx[mu], chain[mu], work.dfcbar[mu])
+  backpropLevel3TangentPhase(hsp, work.dgEffbar, work.dl2bar, work.dflxbar, l2, sc.ma3, sc.alp3)
+
+  # Phase 4: reverse the Level 2 projection and tangent contributions
+  accumulateProjectionAdjoint(work.dl2xbar, hsp.state.l2x, hsp.work.preProjLevel2Chain, work.dl2bar, work.dfl2bar)
+  backpropPairTangentPhase(2, hsp, l1, work.dl2xbar, work.dl1bar, work.dgEffbar, sc.ma2, sc.alp2,
+                           hsp.work.tm1, hsp.work.tm2)
+
+  # Phase 5: reverse the Level 1 projection and tangent contributions
+  accumulateProjectionAdjoint(work.dl1xbar, hsp.state.l1x, hsp.work.preProjLevel1Chain, work.dl1bar, work.dfl1bar)
+  backpropPairTangentPhase(1, hsp, hsp.state.gf, work.dl1xbar, work.dl1xbar, work.dgEffbar, sc.ma1, sc.alp1,
+                           hsp.work.tm1, hsp.work.tm2)
+
+  # Phase 6: return the adjoint with respect to the multiplicative tangent `dg*g`
+  threads:
+    for mu in 0..<4:
+      gbar[mu] := work.dgEffbar[mu]
diff --git a/src/gauge/hypsmear2.nim b/src/gauge/hypsmear2.nim
index 2dda26dd..a8b452ca 100644
--- a/src/gauge/hypsmear2.nim
+++ b/src/gauge/hypsmear2.nim
@@ -15,11 +15,11 @@ type
     gf: array[4,F]
     hl: HaloLayout[L]
     hm: HaloMap[L]
-    l1x: FieldArray[L.V,T]
-    l2x: FieldArray[L.V,T]
-    l1: FieldArray[L.V,T]
-    l2: FieldArray[L.V,T]
-    flx: FieldArray[L.V,T]
+    l1x: FieldArray[2,L.V,T]
+    l2x: FieldArray[2,L.V,T]
+    l1: FieldArray[2,L.V,T]
+    l2: FieldArray[2,L.V,T]
+    flx: FieldArray[1,L.V,T]
     hgf: array[4,Halo[L,F,T]]
     h1x: array[4,array[4,Halo[L,F,T]]]
     h2x: array[4,array[4,Halo[L,F,T]]]
diff --git a/src/gauge/smearutil.nim b/src/gauge/smearutil.nim
index 8b3381af..086ffda3 100644
--- a/src/gauge/smearutil.nim
+++ b/src/gauge/smearutil.nim
@@ -50,3 +50,538 @@ proc symStapleDeriv*(f1, f2: auto;  # output
   f1 += sm2.field
   toc("symStapleDeriv")
 
+template symStapleVJP*(f1, f2: auto;  # output
+                       g1, g2: auto; s1, s2: auto;  # same as symStaple
+                       c: auto, s: auto;  # chain and shift
+                       tm1, tm2: auto;  # temporary fields
+                       sm1, sm2: auto  # shifts
+                      ) =
+  ## Alias for symStapleDeriv using kernel naming.
+  symStapleDeriv(f1, f2, g1, g2, s1, s2, c, s, tm1, tm2, sm1, sm2)
+
+template shiftedAssign(sh, tmp, expr: untyped) =
+  tmp := expr
+  threadBarrier()
+  discard sh ^*! tmp
+  threadBarrier()
+
+template shiftedAccumulate(dst, sh, tmp, expr: untyped) =
+  shiftedAssign(sh, tmp, expr)
+  dst += sh.field
+
+proc symStapleHVP*(df1, df2, acc1, acc2: auto;  # output: directional second derivative wrt g1,g2,c; acc1,acc2 are pre-allocated temp fields
+                      g1, g2: auto; s1, s2: auto;  # same as symStaple
+                      c: auto, s: auto;            # chain and its shift
+                      dg1, dg2: auto;              # input variation directions
+                      dc: auto;                    # variation of the chain
+                      ds1, ds2, dsc: auto;         # PRE-SHIFTED tangent shifters
+                      tm1, tm2: auto;              # temporary fields
+                      sm1, sm2: auto;              # shifts
+                      eps: float = 0.0) =
+  ## Analytical directional second derivative of the symmetric staple backprop.
+  ##
+  ## Given the first-derivative kernel
+  ##   (f1,f2) = symStapleDeriv(g1,g2; c,s),
+  ##
+  ## this returns, in directions (dg1,dg2,dc),
+  ##   (df1,df2) = d/dε [ symStapleDeriv(g1+ε dg1, g2+ε dg2; c+ε dc) ] |_{ε=0},
+  ##
+  ## including the dependence on the shifted fields s1 = shift(g1),
+  ## s2 = shift(g2), and s = shift(c) using the same shifter geometry
+  ## provided in the arguments.
+  ##
+  ## ds1, ds2, dsc are PRE-CREATED shifters for dg1, dg2, dc respectively.
+  ## The caller must:
+  ##   1. Create shifters OUTSIDE threads block with newShifter(field, dir, 1)
+  ##   2. Apply shifts INSIDE threads block with ^*! before calling this function
+  ##   3. Pass the shifter objects (not .field) to this function
+  ##   4. Pass pre-allocated acc1, acc2 fields; no allocation inside threads.
+  discard eps
+  tic()
+  mixin adj
+
+  # Clear accumulators (pre-allocated by caller to avoid allocation inside threads)
+  acc1 := 0
+  acc2 := 0
+
+  # Base shifted fields (inputs are expected to be pre-shifted).
+  let s1b = s1.field
+  let s2b = s2.field
+  let sb  = s.field
+
+  # Use passed shifters' .field for pre-shifted tangents.
+  let ds1b = ds1.field
+  let ds2b = ds2.field
+  let dsb  = dsc.field
+
+  # d(sm1) from dtm1 = dg1† c s1 + g1† c ds1 + g1† dc s1
+  tm1 := dg1.adj * c
+  tm1 := tm1 * s1b
+  tm2 := g1.adj * c
+  tm2 := tm2 * ds1b
+  tm1 += tm2
+  tm2 := g1.adj * dc
+  tm2 := tm2 * s1b
+  tm1 += tm2
+  threadBarrier()
+  discard sm1 ^*! tm1
+  threadBarrier()
+
+  # d(sm2) from dtm2 pieces:
+  #   dg2† g1 s  +  g2† dg1 s  +  g2† g1 ds
+  #   + dc† g1 s2 + c† dg1 s2 + c† g1 ds2
+  tm1 := dg2.adj * g1
+  tm1 := tm1 * sb
+  tm2 := g2.adj * dg1
+  tm2 := tm2 * sb
+  tm1 += tm2
+  tm2 := g2.adj * g1
+  tm2 := tm2 * dsb
+  tm1 += tm2
+  tm2 := dc.adj * g1
+  tm2 := tm2 * s2b
+  tm1 += tm2
+  tm2 := c.adj * dg1
+  tm2 := tm2 * s2b
+  tm1 += tm2
+  tm2 := c.adj * g1
+  tm2 := tm2 * ds2b
+  tm1 += tm2
+  threadBarrier()
+  discard sm2 ^*! tm1
+  threadBarrier()
+
+  # acc1 contributions (was df1)
+  tm1 := dg2 * s1b
+  tm1 := tm1 * sb.adj
+  acc1 += tm1
+
+  tm1 := g2 * ds1b
+  tm1 := tm1 * sb.adj
+  acc1 += tm1
+
+  tm1 := g2 * s1b
+  tm1 := tm1 * dsb.adj
+  acc1 += tm1
+
+  tm1 := dc * s1b
+  tm1 := tm1 * s2b.adj
+  acc1 += tm1
+
+  tm1 := c * ds1b
+  tm1 := tm1 * s2b.adj
+  acc1 += tm1
+
+  tm1 := c * s1b
+  tm1 := tm1 * ds2b.adj
+  acc1 += tm1
+
+  acc1 += sm2.field
+
+  # acc2 contributions (was df2)
+  tm1 := dg1 * sb
+  tm1 := tm1 * s1b.adj
+  acc2 += tm1
+
+  tm1 := g1 * dsb
+  tm1 := tm1 * s1b.adj
+  acc2 += tm1
+
+  tm1 := g1 * sb
+  tm1 := tm1 * ds1b.adj
+  acc2 += tm1
+
+  acc2 += sm1.field
+
+  # Add to outputs (no 0.5 factor - the derivative is exact)
+  df1 += acc1
+  df2 += acc2
+
+  toc("symStapleHVP")
+
+proc symStapleJVP*(ds: auto, alp: float,
+                       g1, g2: auto, s1, s2: auto,
+                       dg1, dg2: auto, ds1, ds2: auto,
+                       tm: auto, sm: auto) =
+  ## Forward tangent of symStaple.
+  ##
+  ## Computes: ds += alp * d/dε[ symStaple(g1+ε dg1, g2+ε dg2, ...) ]|_{ε=0}
+  ##
+  ## Recall symStaple computes:
+  ##   s += alp * [ shift_back(g1† g2 s1) + g1 s2 s1† ]
+  ##
+  ## Tangent:
+  ##   ds += alp * [ shift_back(dg1† g2 s1 + g1† dg2 s1 + g1† g2 ds1)
+  ##               + dg1 s2 s1† + g1 ds2 s1† + g1 s2 ds1† ]
+  tic()
+  mixin adj
+  # Term 1: shift_back(dg1† g2 s1 + g1† dg2 s1 + g1† g2 ds1)
+  tm := dg1.adj * g2 * s1.field
+  tm += g1.adj * dg2 * s1.field
+  tm += g1.adj * g2 * ds1.field
+  discard sm ^* tm
+  ds += alp * sm.field
+
+  # Term 2: dg1 s2 s1† + g1 ds2 s1† + g1 s2 ds1†
+  ds += alp * (dg1 * s2.field * s1.field.adj)
+  ds += alp * (g1 * ds2.field * s1.field.adj)
+  ds += alp * (g1 * s2.field * ds1.field.adj)
+  toc("symStapleJVP")
+
+proc symStapleJVPVJP*(dg1bar, dg2bar: auto, alp: float,
+                          g1, g2: auto, s1, s2: auto,
+                          dsbar: auto, shiftedDsbar: auto,
+                          tm1, tm2: auto,
+                          sm1, sm2: auto) =
+  ## Adjoint of symStapleJVP w.r.t. (dg1, dg2).
+  ##
+  ## Given dsbar (the adjoint seed), accumulates into (dg1bar, dg2bar) such that:
+  ##   <dsbar, symStapleJVP(dg1, dg2, ds1, ds2, ...)> = <dg1bar, dg1> + <dg2bar, dg2>
+  ##
+  ## This is the COMPLETE adjoint including terms from shifted tangents ds1, ds2.
+  ##
+  ## Parameters:
+  ##   dg1bar, dg2bar: output (accumulated)
+  ##   g1, g2: gauge links (same as symStapleJVP)
+  ##   s1, s2: PRE-SHIFTED gauge link shifters, must be freshly applied before calling:
+  ##           discard s1 ^*! g1; discard s2 ^*! g2; threadBarrier()
+  ##   dsbar: adjoint seed
+  ##   shiftedDsbar: scratch forward shifter in the g1 direction, reused to shift dsbar
+  ##   tm1, tm2: temporary fields
+  ##   sm1: backward shifter in g1 direction (same as symStapleJVP's sm)
+  ##   sm2: backward shifter in g2 direction
+  ##
+  ## Recall symStapleJVP computes:
+  ##   ds += alp * [ shift_back_ν(dg1† g2 s1 + g1† dg2 s1 + g1† g2 ds1)
+  ##               + dg1 s2 s1† + g1 ds2 s1† + g1 s2 ds1† ]
+  ##
+  ## where ν is the g1 direction, μ is the g2 direction,
+  ## s1 = g1 shifted forward in μ, s2 = g2 shifted forward in ν,
+  ## ds1 = dg1 shifted forward in μ, ds2 = dg2 shifted forward in ν.
+  ##
+  ## The adjoint has the SAME STRUCTURE as symStapleDeriv but with different field roles:
+  ## - In symStapleDeriv: chain c is the linear input
+  ## - Here: (dg1, dg2) are the linear inputs, and we treat dsbar as the chain
+  ##
+  ## The complete adjoint is:
+  ##   dg1bar += alp * [ g2 s1 (shift_fwd_ν dsbar)† + dsbar s1 s2† ]
+  ##           + alp * shift_back_μ[ g2 g1 (shift_fwd_ν dsbar) + dsbar† g1 s2 ]
+  ##   dg2bar += alp * g1 (shift_fwd_ν dsbar) s1†
+  ##           + alp * shift_back_ν[ g1 dsbar s1† ]
+  tic()
+  mixin adj
+
+  shiftedAssign(shiftedDsbar, tm1, dsbar)
+
+  # === Terms from dg1 directly (A, B) ===
+  # Term A: ds[x] += alp * dg1[x+ν]† g2[x+ν] s1[x+ν]  (from shift_back in ν)
+  # Shift dsbar forward in ν once, then apply the local adjoint
+  # g2 * s1 * shift_fwd_ν(dsbar)†.
+  tm2 := g2 * s1.field * shiftedDsbar.field.adj
+  dg1bar += alp * tm2
+
+  # Term B: ds[x] += alp * dg1[x] s2_orig[x] s1[x]†
+  # Adjoint: dg1bar[x] += alp * dsbar[x] s1.field[x] s2_orig.field[x]†
+  #        = alp * dsbar[x] s1.field[x] s2.field[x]†
+  tm2 := dsbar * s1.field * s2.field.adj
+  dg1bar += alp * tm2
+
+  # === Terms from dg2 directly (C) ===
+  # Term C: ds[x] += alp * g1[x+ν]† dg2[x+ν] s1[x+ν]  (from shift_back in ν)
+  # Adjoint: dg2bar[y] += alp * g1[y] dsbar[y-ν] s1.field[y]†
+  #        = alp * g1[y] shiftedDsbar.field[y] s1.field[y]†
+  tm2 := g1 * shiftedDsbar.field * s1.field.adj
+  dg2bar += alp * tm2
+
+  # === Terms from ds1 = shifted dg1 (D, F) ===
+  # These two terms contribute backward shifts in μ.
+  #
+  # Term D: shift_back_μ(g2† * g1 * shift_fwd_ν(dsbar))
+  # Then shift backward in μ using sm2.
+  shiftedAssign(sm2, tm2, g2.adj * g1 * shiftedDsbar.field)  # sm2.field[z] = tm2[z+μ]
+  dg1bar += alp * sm2.field
+
+  # Term F: shift_back_μ(dsbar† * g1 * s2)
+  # Then shift backward in μ.
+  shiftedAssign(sm2, tm2, dsbar.adj * g1 * s2.field)
+  dg1bar += alp * sm2.field
+
+  # === Term from ds2 = shifted dg2 (E) ===
+  # Term E: shift_back_ν(g1† * dsbar * s1)
+  # Then shift backward in ν using sm1.
+  shiftedAssign(sm1, tm2, g1.adj * dsbar * s1.field)
+  dg2bar += alp * sm1.field
+
+  toc("symStapleJVPVJP")
+
+proc symStapleHVP*(df1, df2, acc1, acc2: auto;  # output + pre-allocated accumulators
+                      g1, g2: auto; s1, s2: auto;  # same as symStaple
+                      c: auto, s: auto;            # chain and shift (held fixed)
+                      dg1, dg2: auto;              # input variation directions
+                      ds1, ds2, dsc: auto;         # PRE-SHIFTED tangent shifters
+                      tm1, tm2: auto;              # temporary fields
+                      sm1, sm2: auto;              # shifts
+                      eps: float = 0.0) =
+  ## Compatibility wrapper when no upstream chain variation dc is provided.
+  ## Creates a zero dc field internally.
+  var dc {.noInit.}: type(c)
+  dc := 0
+  symStapleHVP(df1, df2, acc1, acc2, g1, g2, s1, s2, c, s, dg1, dg2, dc, ds1, ds2, dsc, tm1, tm2, sm1, sm2, eps)
+
+proc symStapleVJPChain*(cbar: auto;  # output: adjoint wrt chain (accumulated)
+                               g1, g2: auto; s1, s2: auto;  # geometry (same as symStapleDeriv)
+                               f1bar, f2bar: auto;  # adjoint seeds
+                               shiftedF2bar, shiftedF1bar: auto;  # scratch forward shifters in g1/g2 directions
+                               tm1, tm2: auto;  # temporaries
+                               sm1: auto  # backward shifter in g1 direction
+                              ) =
+  ## Adjoint of symStapleDeriv with respect to the chain field c.
+  ##
+  ## Given (f1bar, f2bar), computes cbar such that:
+  ##   ⟨(f1bar,f2bar), symStapleDeriv(g1,g2,c)⟩ = ⟨cbar, c⟩
+  ##
+  ## s1: forward shifter in g2=μ direction (initially holds g1 shifted)
+  ## s2: forward shifter in g1=ν direction (initially holds g2 shifted)
+  ## shiftedF2bar shifts `f2bar` in the g1 direction, shiftedF1bar shifts `f1bar` in the g2 direction.
+  tic()
+  mixin adj
+
+  # s1.field[x] = g1[x-μ] where μ = g2 direction (forward shift gets value from behind)
+  # s2.field[x] = g2[x-ν] where ν = g1 direction
+
+  # === Term 1 (line 47): f1[x] += c[x] s1[x] s2[x]† ===
+  # cbar[x] += f1bar[x] s2[x] s1[x]†
+  tm1 := f1bar * s2.field * s1.field.adj
+  cbar += tm1
+
+  # === Term 2 (line 46): f1[x] += g2[x] s1g[x] c[x-ν]† ===
+  # For f = M c†, adjoint is cbar = fbar† M
+  # cbar[z] = f1bar[z+ν]† g2[z+ν] g1[z+ν-μ]
+  # Compute expr[w] = f1bar[w]† g2[w] s1.field[w] at site w
+  # Then cbar[z] = expr[z+ν] → BACKWARD shift in ν (sm1)
+  shiftedAccumulate(cbar, sm1, tm1, f1bar.adj * g2 * s1.field)
+
+  # === Term 3 (line 48): f2[x] += g1[x] c[x-ν] s1g[x]† ===
+  # Adjoint: cbar[z] = g1[z+ν]† f2bar[z+ν] g1[z+ν-μ]
+  # Compute expr[w] = g1[w]† f2bar[w] s1.field[w] at site w
+  # Then cbar[z] = expr[z+ν] → BACKWARD shift in ν (sm1)
+  shiftedAccumulate(cbar, sm1, tm1, g1.adj * f2bar * s1.field)
+
+  # === Term 6 (line 49 from 39): f2[x] += g1[x+ν]† c[x+ν] g1[x+ν-μ] ===
+  # Adjoint: cbar[z] = g1[z] f2bar[z-ν] g1[z-μ]†
+  shiftedAssign(shiftedF2bar, tm2, f2bar)
+  tm1 := g1 * shiftedF2bar.field * s1.field.adj
+  cbar += tm1
+
+  # === Term 4 (line 50A from 40): f1[x] += g2[x+μ]† g1[x+μ] c[x+μ-ν] ===
+  # Adjoint: cbar[z] = g1[z+ν]† g2[z+ν] f1bar[z-μ+ν]
+  shiftedAssign(shiftedF1bar, tm2, f1bar)
+  shiftedAccumulate(cbar, sm1, tm1, g1.adj * g2 * shiftedF1bar.field)
+
+  # === Term 5 (line 50B from 41): f1[x] += c[x+μ]† g1[x+μ] g2[x+μ-ν] ===
+  # For f = c† M, adjoint is cbar = M fbar†
+  # cbar[z] = g1[z] g2[z-ν] f1bar[z-μ]†
+  tm1 := g1 * s2.field * shiftedF1bar.field.adj
+  cbar += tm1
+
+  toc("symStapleVJPChain")
+
+proc symStapleHVPVJP*(dg1bar, dg2bar, dcbar: auto;  # output (accumulated)
+                          g1, g2: auto; s1, s2: auto;   # gauge links (fixed)
+                          c: auto, s: auto;              # chain (fixed)
+                          f1bar, f2bar: auto;            # adjoint seeds
+                          shiftedF2bar, shiftedF1bar: auto;  # scratch forward shifters in g1/g2 directions
+                          tm1, tm2: auto;                # temps
+                          sm1, sm2: auto) =              # shifters
+  ## Adjoint of symStapleHVP w.r.t. (dg1, dg2, dc).
+  ##
+  ## Given (f1bar, f2bar), accumulates into (dg1bar, dg2bar, dcbar) such that:
+  ##   <(f1bar, f2bar), symStapleHVP(dg1, dg2, dc)> = <dg1bar, dg1> + <dg2bar, dg2> + <dcbar, dc>
+  ##
+  ## s1, s2, s: PRE-SHIFTED shifters (same as symStapleHVP)
+  ##   s1.field = g1 shifted, s2.field = g2 shifted, s.field = c shifted
+  ## sm1: backward shifter in g1 direction
+  ## sm2: backward shifter in g2 direction
+  ##
+  ## Recall symStapleHVP computes (from lines 98-175 in the forward pass):
+  ##   Part 1: sm1 terms from dg1†*c*s1 + g1†*c*ds1 + g1†*dc*s1
+  ##   Part 2: sm2 terms from dg2†*g1*s + g2†*dg1*s + g2†*g1*ds + dc†*g1*s2 + c†*dg1*s2 + c†*g1*ds2
+  ##   Part 3: acc1 terms (local)
+  ##   Part 4: acc2 terms (local)
+  ##
+  ## The adjoint reverses all these operations.
+  tic()
+  mixin adj
+
+  # Read pre-shifted fields (these are valid at entry)
+  # s1.field = g1 shifted in μ (g2 direction)
+  # s2.field = g2 shifted in ν (g1 direction)
+  # s.field = c shifted in ν (g1 direction)
+
+  # === Adjoint of acc1 local terms (lines 136-158) ===
+
+  # Term 1 (line 136-138): acc1 += dg2 * s1b * sb†
+  # Linear in dg2: adjoint is dg2bar += f1bar * sb * s1b†
+  tm1 := f1bar * s.field * s1.field.adj
+  dg2bar += tm1
+
+  # Term 2 (line 140-142): acc1 += g2 * ds1b * sb†
+  # Linear in ds1b = shifted dg1: adjoint is dg1bar += shift_back_μ(g2† * f1bar * sb)
+  tm1 := g2.adj * f1bar * s.field
+  threadBarrier()
+  discard sm2 ^*! tm1  # sm2 shifts back in g2 (μ) direction
+  threadBarrier()
+  dg1bar += sm2.field
+
+  # Term 3 (line 144-146): acc1 += g2 * s1b * dsb†
+  # Linear in dsb† where dsb = shifted dc
+  # For f = M * A†: <fbar, M A†> = <fbar† M, A>
+  # M = g2 * s1b, A = dc shifted in ν
+  # Adjoint: dcbar[z] = (fbar† M)[z+ν] = shift_back_ν(f1bar† * g2 * s1.field)
+  tm1 := f1bar.adj * g2 * s1.field
+  threadBarrier()
+  discard sm1 ^*! tm1
+  threadBarrier()
+  dcbar += sm1.field
+
+  # Term 4 (line 148-150): acc1 += dc * s1b * s2b†
+  # Linear in dc: adjoint is dcbar += f1bar * s2b * s1b†
+  tm1 := f1bar * s2.field * s1.field.adj
+  dcbar += tm1
+
+  # Term 5 (line 152-154): acc1 += c * ds1b * s2b†
+  # Linear in ds1b = shifted dg1: adjoint is dg1bar += shift_back_μ(c† * f1bar * s2b)
+  tm1 := c.adj * f1bar * s2.field
+  threadBarrier()
+  discard sm2 ^*! tm1
+  threadBarrier()
+  dg1bar += sm2.field
+
+  # Term 6 (line 156-158): acc1 += c * s1b * ds2b†
+  # Linear in ds2b† where ds2b = shifted dg2
+  # For f = M * A†: <fbar, M A†> = <fbar† M, A>
+  # M = c * s1b, A = dg2 shifted in ν
+  # Adjoint: dg2bar[z] = (fbar† M)[z+ν] = shift_back_ν(f1bar† * c * s1.field)
+  tm1 := f1bar.adj * c * s1.field
+  threadBarrier()
+  discard sm1 ^*! tm1
+  threadBarrier()
+  dg2bar += sm1.field
+
+  # === Adjoint of acc2 local terms (lines 163-173) ===
+
+  # Term 8 (line 163-165): acc2 += dg1 * sb * s1b†
+  # Linear in dg1: adjoint is dg1bar += f2bar * s1b * sb†
+  tm1 := f2bar * s1.field * s.field.adj
+  dg1bar += tm1
+
+  # Term 9 (line 167-169): acc2 += g1 * dsb * s1b†
+  # Linear in dsb = shifted dc: adjoint is dcbar += shift_back_ν(g1† * f2bar * s1b)
+  tm1 := g1.adj * f2bar * s1.field
+  threadBarrier()
+  discard sm1 ^*! tm1
+  threadBarrier()
+  dcbar += sm1.field
+
+  # Term 10 (line 171-173): acc2 += g1 * sb * ds1b†
+  # Linear in ds1b† where ds1b = shifted dg1
+  # For f = M * A†: <fbar, M A†> = <fbar† M, A>
+  # M = g1 * sb, A = dg1 shifted in μ
+  # Adjoint: dg1bar[z] = (fbar† M)[z+μ] = shift_back_μ(f2bar† * g1 * s.field)
+  tm1 := f2bar.adj * g1 * s.field
+  threadBarrier()
+  discard sm2 ^*! tm1
+  threadBarrier()
+  dg1bar += sm2.field
+
+  # === Adjoint of sm1 shifted term (lines 98-109, contributes to acc2 via line 175) ===
+  # Forward: tm1 = dg1† * c * s1b + g1† * c * ds1b + g1† * dc * s1b
+  # sm1.field = shift_back_ν(tm1), then acc2 += sm1.field
+  #
+  shiftedAssign(shiftedF2bar, tm2, f2bar)
+
+  # For term dg1† * c * s1b shifted by sm1:
+  # <f2bar, shift_back_ν(dg1† * c * s1b)> = <shift_fwd_ν(f2bar), dg1† * c * s1b>
+  # For A†: <sf, A† M> = <M sf†, A>
+  # where M = c * s1b, sf = shift_fwd_ν(f2bar) = shiftedF2bar.field, A = dg1
+  # dg1bar += M * sf† = c * s1.field * shiftedF2bar.field†
+  tm1 := c * s1.field * shiftedF2bar.field.adj
+  dg1bar += tm1
+
+  # For term g1† * c * ds1b in sm1:
+  # <shift_fwd_ν(f2bar), g1† * c * ds1b> where ds1b = dg1 shifted in μ
+  # = <c† g1 sf, ds1b> where sf = shiftedF2bar.field
+  # = <shift_back_μ(c† g1 sf), dg1>
+  tm1 := c.adj * g1 * shiftedF2bar.field
+  threadBarrier()
+  discard sm2 ^*! tm1
+  threadBarrier()
+  dg1bar += sm2.field
+
+  # For term g1† * dc * s1b in sm1:
+  # <shift_fwd_ν(f2bar), g1† * dc * s1b> where sf = shiftedF2bar.field
+  # Linear in dc (middle position): L(dc) = g1† * dc * s1b
+  # L*(Y) = (g1†)† * Y * (s1b)† = g1 * Y * s1b† = g1 * sf * s1.field†
+  # dcbar += g1 * shiftedF2bar.field * s1.field†
+  tm1 := g1 * shiftedF2bar.field * s1.field.adj
+  dcbar += tm1
+
+  # === Adjoint of sm2 shifted term (lines 111-133, contributes to acc1 via line 160) ===
+  # Forward: tm1 = dg2† * g1 * sb + g2† * dg1 * sb + g2† * g1 * dsb
+  #              + dc† * g1 * s2b + c† * dg1 * s2b + c† * g1 * ds2b
+  # sm2.field = shift_back_μ(tm1), then acc1 += sm2.field
+  #
+  shiftedAssign(shiftedF1bar, tm2, f1bar)
+
+  # s.field still has c shifted (sb)
+  # s2.field still holds the shifted g2 links from the caller.
+
+  # For dg2† * g1 * sb:
+  # <f1bar, shift_back_μ(dg2† * g1 * sb)> = <shift_fwd_μ(f1bar), dg2† * g1 * sb>
+  # For A†: <sf, A† M> = <M sf†, A>
+  # where M = g1 * sb, sf = shiftedF1bar.field, A = dg2
+  # dg2bar += M * sf† = g1 * s.field * shiftedF1bar.field†
+  tm1 := g1 * s.field * shiftedF1bar.field.adj
+  dg2bar += tm1
+
+  # For g2† * dg1 * sb:
+  # <sf, g2† * dg1 * sb> where sf = shiftedF1bar.field (f1bar shifted forward in μ)
+  # Linear in dg1 (middle position): L(dg1) = g2† * dg1 * sb
+  # L*(Y) = (g2†)† * Y * (sb)† = g2 * Y * sb† = g2 * sf * s.field†
+  # dg1bar += g2 * shiftedF1bar.field * s.field†
+  tm1 := g2 * shiftedF1bar.field * s.field.adj
+  dg1bar += tm1
+
+  # For g2† * g1 * dsb where dsb = dc shifted in ν:
+  # <sf, g2† * g1 * dsb> = <g1† g2 sf, dsb> = <shift_back_ν(g1† g2 sf), dc>
+  tm1 := g1.adj * g2 * shiftedF1bar.field
+  threadBarrier()
+  discard sm1 ^*! tm1
+  threadBarrier()
+  dcbar += sm1.field
+
+  # For dc† * g1 * s2b:
+  # <sf, dc† * g1 * s2b> where sf = shiftedF1bar.field, s2b = s2.field = g2 shifted
+  # For A†: <sf, A† M> = <M sf†, A>
+  # where M = g1 * s2b, sf = shiftedF1bar.field, A = dc
+  # dcbar += M * sf† = g1 * s2.field * shiftedF1bar.field†
+  tm1 := g1 * s2.field * shiftedF1bar.field.adj
+  dcbar += tm1
+
+  # For c† * dg1 * s2b:
+  # <sf, c† * dg1 * s2b> where sf = shiftedF1bar.field
+  # Linear in dg1 (middle position): L(dg1) = c† * dg1 * s2b
+  # L*(Y) = (c†)† * Y * (s2b)† = c * Y * s2b† = c * sf * s2.field†
+  # dg1bar += c * shiftedF1bar.field * s2.field†
+  tm1 := c * shiftedF1bar.field * s2.field.adj
+  dg1bar += tm1
+
+  # For c† * g1 * ds2b where ds2b = dg2 shifted in ν:
+  # <sf, c† * g1 * ds2b> = <g1† c sf, ds2b> = <shift_back_ν(g1† c sf), dg2>
+  tm1 := g1.adj * c * shiftedF1bar.field
+  threadBarrier()
+  discard sm1 ^*! tm1
+  threadBarrier()
+  dg2bar += sm1.field
+
+  toc("symStapleHVPVJP")
diff --git a/src/maths/matrixFunctions.nim b/src/maths/matrixFunctions.nim
index 6e3f597c..bcb307a0 100644
--- a/src/maths/matrixFunctions.nim
+++ b/src/maths/matrixFunctions.nim
@@ -9,6 +9,7 @@ export matinv
 import matexp
 export matexp
 import projUderiv
+export projUderiv
 getOptimPragmas()
 
 proc determinantN*(a: auto): auto =
@@ -298,7 +299,7 @@ template rsqrtPH*[T:Mat1](x: T): T =
   rsqrtPH(r, x)
   r
 
-proc projectUrsqrt(r: var Mat1; x: Mat2, eps = 1e-20) {.alwaysInline.} =
+proc projectUrsqrt*(r: var Mat1; x: Mat2, eps = 1e-20) {.alwaysInline.} =
   #let t = x.adj * x   # issues with gcc
   let xa = x.adj
   var t = xa * x
@@ -356,6 +357,411 @@ proc projectUderiv*(r: var Mat1, x: Mat2, c: Mat3) =
   #echo u, x, c
   projectUderiv(r, u, x, c)
 
+proc projectUVJP*(r: var Mat1, u: Mat2, x: Mat3, chain: Mat4, eps = 1e-20) =
+  ## Alias for projectUderiv with naming based on the kernel.
+  projectUderiv(r, u, x, chain, eps)
+
+proc projectUVJP*(r: var Mat1, x: Mat2, c: Mat3) =
+  ## Convenience alias for projectUderiv without providing u.
+  projectUderiv(r, x, c)
+
+proc projectUHVPu*(r: var Mat1, u: Mat2, x: Mat3, c: Mat4, dx: Mat3, dc: Mat4, eps = 1e-20) =
+  ## Analytical directional second derivative of the unitary projection.
+  ##
+  ## Given:
+  ##   u     = projectU(x)
+  ##   r₁(x) = projectUderiv(u, x, chain)
+  ##
+  ## this returns
+  ##   r = d/dε [ r₁(x + ε dx, chain + ε dc) ] |_{ε=0}
+  ##
+  ## by differentiating the algebra used in `projectUderiv`:
+  ##   Z = (X†X)^(-1/2),  Y = Z^(-1)
+  ##   R0 = C Z
+  ##   T2 solves  Y T2 + T2 Y = U† R0
+  ##   S  = T2 + T2†
+  ##   r1 = R0 - X S
+  ##
+  ## Variations:
+  ##   dA  = X† dX + dX† X
+  ##   dY  solves Y dY + dY Y = dA
+  ##   dZ  = - Z dY Z
+  ##   dR0 = dC Z + C dZ
+  ##   dU  = dX Z + X dZ   ,   dU† = Z dX† + dZ X†
+  ##   dB  = dU† R0 + U† dR0          (B = U† R0)
+  ##   dT2 solves Y dT2 + dT2 Y = dB - dY T2 - T2 dY
+  ##   dS  = dT2 + dT2†
+  ##   r   = dR0 - dX S - X dS
+  ##
+  ## This keeps all Sylvester solves local and avoids another outer finite
+  ## difference.
+  discard eps  # parameter kept for API compatibility
+  var z, y: Mat1
+  projectUrsqrt(z, x)   # Z
+  inverse(y, z)         # Y = Z^{-1} = sqrt(X†X)
+
+  # Base first-derivative pieces (same as projectUderiv).
+  var r0, t1, s: Mat1
+  mul(r0, c, z)       # R0 = C Z
+  mul(t1, u.adj, r0)      # B  = U† R0
+  # Solve directly for S: Y S + S Y = B + B†
+  var bSym: Mat1
+  bSym := t1
+  bSym += t1.adj
+  sylsolve(s, y, bSym)
+
+  # dA = X† dX + dX† X
+  var da, tmp: Mat1
+  mul(da, x.adj, dx)
+  mul(tmp, dx.adj, x)
+  da += tmp
+  # Keep dA Hermitian (numerical symmetrization).
+  da = 0.5*(da + da.adj)
+
+  # dY from sqrt(A): Y dY + dY Y = dA
+  var dy: Mat1
+  sylsolve(dy, y, da)
+  dy = 0.5*(dy + dy.adj)
+
+  # dZ via inverse derivative: dZ = - Z dY Z (exact for Z = Y^{-1}).
+  var dz: Mat1
+  var zdy: Mat1
+  mul(zdy, z, dy)
+  mul(dz, zdy, z)
+  dz *= -1
+  dz = 0.5*(dz + dz.adj)
+
+  # dR0 = dC Z + C dZ
+  var dr0: Mat1
+  mul(dr0, dc, z)
+  mul(tmp, c, dz)
+  dr0 += tmp
+
+  # dU = dX Z + X dZ
+  var du: Mat1
+  mul(du, dx, z)
+  mul(tmp, x, dz)
+  du += tmp
+
+  # dU† = Z dX† + dZ X†
+  var duAdj: Mat1
+  mul(duAdj, z, dx.adj)
+  mul(tmp, dz, x.adj)
+  duAdj += tmp               # full dU† including dZ contribution
+
+  # dB pieces
+  # Full variation: dB = dU† R0 + U† dR0
+  # However, the dR0 contribution through U† dR0 is separate from the direct dR0 term.
+  # We include both here as the Sylvester equation for dS needs the full dB.
+  var db: Mat1
+  mul(db, duAdj, r0)           # dU† R0
+  mul(tmp, u.adj, dr0)         # U† dR0
+  db += tmp                    # full dB
+
+  # rhs for dT2: dB - dY T2 - T2 dY
+  # Solve directly for dS: Y dS + dS Y = d(B+B†) - dY S - S dY
+  var rhs, dyS, Sdy: Mat1
+  # Build full symmetric RHS for dS:
+  # RHS = (dB + dB†) - (dY S + S dY)
+  # Note: dY and S are both Hermitian, so dY S + S dY is Hermitian
+  var dBsym: Mat1
+  # dB = dU† R0 + U† dR0, already in db
+  dBsym := db + db.adj
+  # dY S + S dY (already Hermitian since dY and S are Hermitian)
+  mul(dyS, dy, s)
+  mul(Sdy, s, dy)
+  rhs := dBsym
+  rhs -= dyS
+  rhs -= Sdy
+
+  var ds: Mat1
+  sylsolve(ds, y, rhs)
+  ds = 0.5*(ds + ds.adj)  # Ensure ds is Hermitian
+
+  # Final directional second derivative: dR0 - dX S - X dS
+  tmp := 0
+  mul(tmp, dx, s)
+  r := dr0
+  r -= tmp
+  tmp := 0
+  mul(tmp, x, ds)
+  r -= tmp
+
+proc projectUHVPu*(r: var Mat1, u: Mat2, x: Mat3, c: Mat4, dx: Mat3, eps = 1e-20) =
+  ## Compatibility wrapper when no upstream variation dc is provided.
+  var dc {.noInit.}: type(c)
+  dc := 0
+  projectUHVPu(r, u, x, c, dx, dc, eps)
+
+proc projectUHVP*(r: var Mat1, x: Mat2, c: Mat3, dx: Mat2, eps = 1e-20) =
+  ## Convenience wrapper for projectUHVP when only x is given.
+  var u {.noInit.}: type(r)
+  var dc {.noInit.}: type(c)
+  projectU(u, x)
+  dc := 0
+  projectUHVPu(r, u, x, c, dx, dc, eps)
+
+proc projectUHVP*(r: var Mat1, x: Mat2, c: Mat3, dx: Mat2, dc: Mat3, eps = 1e-20) =
+  ## Convenience wrapper including an upstream variation dc.
+  var u {.noInit.}: type(r)
+  projectU(u, x)
+  projectUHVPu(r, u, x, c, dx, dc, eps)
+
+proc projectUJVP*(du: var Mat1, u: Mat2, x: Mat3, dx: Mat3, eps = 1e-20) =
+  ## Forward tangent of unitary projection.
+  ##
+  ## Computes: du = d/dε[ projectU(x + ε dx) ]|_{ε=0}
+  ##
+  ## Given U = X Z where Z = (X†X)^{-1/2}, Y = Z^{-1} = sqrt(X†X):
+  ##   dU = dX Z + X dZ
+  ## where dZ = -Z dY Z and Y dY + dY Y = dA, dA = X† dX + dX† X
+  discard eps
+  var z, y: Mat1
+  projectUrsqrt(z, x)   # Z = (X†X)^{-1/2}
+  inverse(y, z)         # Y = Z^{-1}
+
+  # dA = X† dX + dX† X (Hermitian)
+  var da, tmp: Mat1
+  mul(tmp, x.adj, dx)
+  da := tmp + tmp.adj
+
+  # Solve Y dY + dY Y = dA
+  var dy: Mat1
+  sylsolve(dy, y, da)
+
+  # dZ = -Z dY Z
+  var dz: Mat1
+  tmp := dy * z
+  dz := z * tmp
+  dz := -dz
+
+  # dU = dX Z + X dZ
+  mul(du, dx, z)
+  tmp := x * dz
+  du += tmp
+
+proc projectUJVP*(du: var Mat1, x: Mat2, dx: Mat2, eps = 1e-20) =
+  ## Convenience wrapper when u is not provided.
+  var u {.noInit.}: type(du)
+  projectU(u, x)
+  projectUJVP(du, u, x, dx, eps)
+
+proc projectUVJPChain*(chainbar: var Mat1, u: Mat2, x: Mat3, rbar: Mat4, eps = 1e-20) =
+  ## Adjoint of projectUderiv with respect to the chain input.
+  ##
+  ## Given: r = projectUderiv(u, x, chain) which computes
+  ##   Z = (X†X)^{-1/2}, Y = Z^{-1}
+  ##   R0 = chain * Z
+  ##   T1 = U† * R0
+  ##   sylsolve(T2, Y, T1)  // Y*T2 + T2*Y = T1
+  ##   S = T2 + T2†
+  ##   r = R0 - X*S
+  ##
+  ## This computes chainbar such that ⟨rbar, r⟩ = ⟨chainbar, chain⟩
+  ## for any chain (the map chain → r is linear).
+  ##
+  ## Derivation:
+  ##   r = chain*Z - X*(T2 + T2†) where Y*T2 + T2*Y = U†*chain*Z
+  ##
+  ##   Term 1: chain*Z contributes Z*rbar to chainbar (Z is Hermitian)
+  ##
+  ##   Term 2: -X*S where S = T2 + T2†
+  ##   ⟨-X*S, rbar⟩ = ⟨S, -X†*rbar⟩
+  ##   Let Q = -X†*rbar, then ⟨S, Q⟩ = ⟨T2+T2†, Q⟩ = ⟨T2, Q+Q†⟩
+  ##   Adjoint of Sylvester Y*T2 + T2*Y = T1 gives: Y*T2bar + T2bar*Y = Q+Q†
+  ##   Then ⟨T1, T2bar⟩ = ⟨U†*chain*Z, T2bar⟩ = ⟨chain, U*T2bar*Z⟩
+  ##
+  ##   Total: chainbar = Z*rbar + U*T2bar*Z
+  discard eps
+  var z, y: Mat1
+  projectUrsqrt(z, x)   # Z = (X†X)^{-1/2}
+  inverse(y, z)         # Y = Z^{-1}
+
+  # Q = -X†*rbar, Q_sym = Q + Q†
+  var q, qsym, tmp: Mat1
+  mul(q, x.adj, rbar)
+  q := -q
+  qsym := q + q.adj
+
+  # Solve Y*T2bar + T2bar*Y = Q_sym
+  var t2bar: Mat1
+  sylsolve(t2bar, y, qsym)
+
+  # chainbar = rbar*Z + U*T2bar*Z
+  mul(chainbar, rbar, z)       # rbar*Z (Z is Hermitian, so Z† = Z)
+  mul(tmp, u, t2bar)
+  tmp := tmp * z
+  chainbar += tmp
+
+proc projectUVJPChain*(chainbar: var Mat1, x: Mat2, rbar: Mat3, eps = 1e-20) =
+  ## Convenience wrapper when u is not provided.
+  var u {.noInit.}: type(chainbar)
+  projectU(u, x)
+  projectUVJPChain(chainbar, u, x, rbar, eps)
+
+proc projectUHVPVJP_dx*(dxbar: var Mat1, u: Mat2, x: Mat3, c: Mat4, rbar: auto, eps = 1e-20) =
+  ## Adjoint of projectUHVP with respect to dx.
+  ##
+  ## Given: r = projectUHVPu(u, x, c, dx) which computes (with dc=0):
+  ##   Z = (X†X)^{-1/2}, Y = Z^{-1}
+  ##   R0 = C Z
+  ##   B = U† R0
+  ##   S solves Y S + S Y = B + B†
+  ##   dA = X† dx + dx† X
+  ##   dY solves Y dY + dY Y = dA
+  ##   dZ = -Z dY Z
+  ##   dR0 = C dZ  (since dc=0)
+  ##   dU = dx Z + X dZ
+  ##   dU† = Z dx† + dZ X†
+  ##   dB = dU† R0 + U† dR0
+  ##   dS solves Y dS + dS Y = (dB + dB†) - dY S - S dY
+  ##   r = dR0 - dx S - X dS
+  ##
+  ## This computes dxbar such that ⟨rbar, r⟩ = ⟨dxbar, dx⟩.
+  ##
+  ## dx appears in:
+  ##   1. Direct: -dx S  →  dxbar += -rbar S†  (S is Hermitian, so S† = S)
+  ##   2. dU = dx Z  →  contribution through dU (NOT dU†!)
+  ##   3. dU† = Z dx†  →  contribution through dU† to dB
+  ##   4. dA = X† dx + dx† X  →  flows through dY, dZ
+  ##
+  ## Backward pass traces through the chain of dependencies.
+  discard eps
+  var z, y: Mat1
+  projectUrsqrt(z, x)   # Z = (X†X)^{-1/2}
+  inverse(y, z)         # Y = Z^{-1}
+
+  # Forward quantities needed for adjoint
+  var r0, b, s, tmp: Mat1
+  mul(r0, c, z)         # R0 = C Z
+  mul(b, u.adj, r0)     # B = U† R0
+  var bSym: Mat1
+  bSym := b + b.adj
+  sylsolve(s, y, bSym)  # Y S + S Y = B + B†
+
+  # === Backward pass ===
+
+  # Step 1: Direct term -dx S
+  # ⟨rbar, -dx S⟩ = ⟨-rbar S, dx⟩ (S is Hermitian)
+  mul(dxbar, rbar, s)
+  dxbar := -dxbar
+
+  # Step 2: Trace through dS
+  # r -= X dS, so rbar gives contribution to dSbar
+  # ⟨rbar, -X dS⟩ = ⟨-X† rbar, dS⟩
+  var dSbar: Mat1
+  mul(dSbar, x.adj, rbar)
+  dSbar := -dSbar
+
+  # dS solves Y dS + dS Y = RHS where RHS = (dB+dB†) - dY S - S dY
+  # RHS is Hermitian (sum of Hermitian terms), so dS is already Hermitian.
+  # The 0.5 symmetrization in forward is just numerical cleanup.
+  # Sylvester adjoint: Y dRHSbar + dRHSbar Y = dSbar
+  var dRHSbar: Mat1
+  sylsolve(dRHSbar, y, dSbar)
+
+  # RHS = (dB + dB†) - dY S - S dY
+  # From (dB + dB†): ⟨dRHSbar, dB + dB†⟩ = ⟨dRHSbar + dRHSbar†, dB⟩
+  var dBbar: Mat1
+  dBbar := dRHSbar + dRHSbar.adj
+
+  # From -dY S - S dY: contribution to dYbar
+  # ⟨dRHSbar, -dY S - S dY⟩ = -⟨dRHSbar S + S dRHSbar, dY⟩
+  var dYbar: Mat1
+  var rhsS, Srhs: Mat1
+  mul(rhsS, dRHSbar, s)
+  mul(Srhs, s, dRHSbar)
+  dYbar := -(rhsS + Srhs)
+
+  # Step 3: Trace through dR0
+  # r += dR0 (positive sign), so ⟨rbar, dR0⟩
+  # dR0 = C dZ (since dc=0)
+  # ⟨rbar, C dZ⟩ = ⟨C† rbar, dZ⟩
+  var dZbar: Mat1
+  mul(dZbar, c.adj, rbar)
+
+  # Step 4: Trace through dB = dU† R0 + U† dR0
+  #
+  # From dU† R0: ⟨dBbar, dU† R0⟩
+  # dU† = Z dx† + dZ X†
+  #
+  # For Z dx†: ⟨dBbar, Z dx† R0⟩ = Re(tr(dBbar† Z dx† R0))
+  #   = Re(tr(R0 dBbar† Z dx†)) = Re(tr((Z† dBbar R0†)† dx†))
+  #   = Re(tr(dx (Z† dBbar R0†))) = redot((Z† dBbar R0†)†, dx)
+  #   = redot(R0 dBbar† Z, dx)
+  # So: dxbar += R0 dBbar† Z
+  var tmp2: Mat1
+  mul(tmp, r0, dBbar.adj)
+  mul(tmp2, tmp, z)
+  dxbar += tmp2
+
+  # For dZ X† in dU†: ⟨dBbar, dZ X† R0⟩ = ⟨R0† X dBbar, dZ⟩
+  # Actually: Re(tr(dBbar† dZ X† R0)) = Re(tr(R0 dBbar† dZ X†))
+  #         = Re(tr(X† R0 dBbar† dZ)) = redot((R0 dBbar†)† X, dZ)
+  #         = redot(dBbar R0† X, dZ)? Let me be more careful.
+  # ⟨dBbar, dZ X† R0⟩ = Re(tr(dBbar† dZ X† R0))
+  # Let A = dBbar†, then tr(A dZ X† R0) = tr(X† R0 A dZ)
+  # = redot((X† R0 A)†, dZ) = redot(A† R0† X, dZ) = redot(dBbar R0† X, dZ)
+  # Hmm, let me use the identity: redot(A, B) = Re(tr(A† B))
+  # redot(dBbar, dZ X† R0) = Re(tr(dBbar† dZ X† R0))
+  # We want ⟨?, dZ⟩ form: Re(tr(?† dZ))
+  # tr(dBbar† dZ X† R0) = tr((X† R0 dBbar†)† dZ)†... no, that's wrong
+  # Actually: tr(A B) = tr(B A), so tr(dBbar† dZ X† R0) = tr(X† R0 dBbar† dZ)
+  # = tr((X† R0 dBbar†)† dZ)† = [tr(dZ† (X† R0 dBbar†))]†
+  # For real part: Re(tr(X† R0 dBbar† dZ)) = redot((X† R0 dBbar†)†, dZ) = redot(dBbar R0† X, dZ)
+  # So: dZbar += dBbar R0† X
+  mul(tmp, dBbar, r0.adj)
+  mul(tmp2, tmp, x)
+  dZbar += tmp2
+
+  # From U† dR0: ⟨dBbar, U† dR0⟩ = ⟨U dBbar, dR0⟩
+  # dR0 = C dZ, so ⟨U dBbar, C dZ⟩ = ⟨C† U dBbar, dZ⟩
+  mul(tmp, u, dBbar)
+  mul(tmp2, c.adj, tmp)
+  dZbar += tmp2
+
+  # Step 5: Trace through dZ = -Z dY Z
+  # dZ is then numerically symmetrized: dZ_final = 0.5*(dZ + dZ†)
+  # But since Z and dY are Hermitian, dZ = -Z dY Z is already Hermitian.
+  # So the 0.5 factor is just numerical cleanup and doesn't affect the adjoint.
+  # ⟨dZbar, -Z dY Z⟩ = -⟨Z dZbar Z, dY⟩
+  var zDzbarZ: Mat1
+  mul(tmp, z, dZbar)
+  mul(zDzbarZ, tmp, z)
+  dYbar -= zDzbarZ
+
+  # Step 6: Trace through dY
+  # Y dY + dY Y = dA, then dY is symmetrized: dY_final = 0.5*(dY + dY†)
+  # Since dA is Hermitian and Y is Hermitian, dY is already Hermitian.
+  # So the 0.5 factor is just numerical cleanup.
+  # Sylvester adjoint: Y dAbar + dAbar Y = dYbar
+  var dAbar: Mat1
+  sylsolve(dAbar, y, dYbar)
+
+  # Step 7: Trace through dA = X† dx + dx† X
+  # From X† dx: ⟨dAbar, X† dx⟩ = ⟨X dAbar, dx⟩
+  # From dx† X: ⟨dAbar, dx† X⟩ = ⟨X dAbar†, dx⟩ (verified by test!)
+  # Combined: dxbar += X dAbar + X dAbar†
+  mul(tmp, x, dAbar)
+  dxbar += tmp
+  mul(tmp, x, dAbar.adj)
+  dxbar += tmp
+
+proc projectUHVPVJP_dx*(dxbar: var Mat1, x: Mat2, c: Mat3, rbar: Mat4, eps = 1e-20) =
+  ## Convenience wrapper when u is not provided.
+  var u {.noInit.}: type(dxbar)
+  projectU(u, x)
+  projectUHVPVJP_dx(dxbar, u, x, c, rbar, eps)
+
+proc projectUHVPVJP_dc*(dcbar: var Mat1, u: Mat2, x: Mat3, c: Mat4, rbar: auto, eps = 1e-20) =
+  ## Adjoint of projectUHVP with respect to dc (chain tangent).
+  ## This is identical to the VJP w.r.t. the chain input of projectUVJP.
+  projectUVJPChain(dcbar, u, x, rbar, eps)
+
+proc projectUHVPVJP_dc*(dcbar: var Mat1, x: Mat2, c: Mat3, rbar: Mat4, eps = 1e-20) =
+  ## Convenience wrapper when u is not provided.
+  projectUVJPChain(dcbar, x, rbar, eps)
+
 proc projectSU*(r: var Mat1; x: Mat2) =
   const nc = r.nrows
   var m{.noinit.}: type(r)
diff --git a/src/physics/colorOld.nim b/src/physics/colorOld.nim
index 91dc40da..84e33899 100644
--- a/src/physics/colorOld.nim
+++ b/src/physics/colorOld.nim
@@ -262,6 +262,48 @@ template projectUderiv*(r: var Color, u: Color2, x: Color3, chain: Color4) =
   projectUderiv(r[], u[], x[], chain[])
 template projectUderiv*(r: var Color, x: Color3, chain: Color4) =
   projectUderiv(r[], x[], chain[])
+template projectUVJP*(r: var Color, u: Color2, x: Color3, chain: Color4) =
+  ## Alias for projectUderiv.
+  projectUderiv(r[], u[], x[], chain[])
+template projectUVJP*(r: var Color, x: Color3, chain: Color4) =
+  ## Alias for projectUderiv (convenience wrapper).
+  projectUderiv(r[], x[], chain[])
+template projectUHVPu*(r: var Color, u, x, chain, dx: Color) =
+  ## Wrapper for the directional second derivative of the unitary projection.
+  projectUHVPu(r[], u[], x[], chain[], dx[])
+template projectUHVP*(r: var Color, x, chain, dx: Color) =
+  ## Wrapper for the directional second derivative of the unitary projection.
+  projectUHVP(r[], x[], chain[], dx[])
+template projectUHVPu*(r: var Color, u, x, chain, dx, dc: Color) =
+  ## Wrapper including an upstream chain tangent dc.
+  projectUHVPu(r[], u[], x[], chain[], dx[], dc[])
+template projectUHVP*(r: var Color, x, chain, dx, dc: Color) =
+  ## Wrapper including an upstream chain tangent dc.
+  projectUHVP(r[], x[], chain[], dx[], dc[])
+template projectUJVP*(du: var Color, u, x, dx: Color) =
+  ## Forward tangent of unitary projection.
+  projectUJVP(du[], u[], x[], dx[])
+template projectUJVP*(du: var Color, x, dx: Color) =
+  ## Forward tangent of unitary projection (convenience wrapper).
+  projectUJVP(du[], x[], dx[])
+template projectUVJPChain*(chainbar: var Color, u, x, rbar: Color) =
+  ## Adjoint of projectUVJP with respect to the chain input.
+  projectUVJPChain(chainbar[], u[], x[], rbar[])
+template projectUVJPChain*(chainbar: var Color, x, rbar: Color) =
+  ## Adjoint of projectUVJP (convenience wrapper).
+  projectUVJPChain(chainbar[], x[], rbar[])
+template projectUHVPVJP_dx*(dxbar: var Color, u, x, c, rbar: Color) =
+  ## Adjoint of projectUHVP with respect to dx.
+  projectUHVPVJP_dx(dxbar[], u[], x[], c[], rbar[])
+template projectUHVPVJP_dx*(dxbar: var Color, x, c, rbar: Color) =
+  ## Adjoint of projectUHVP with respect to dx (convenience wrapper).
+  projectUHVPVJP_dx(dxbar[], x[], c[], rbar[])
+template projectUHVPVJP_dc*(dcbar: var Color, u, x, c, rbar: Color) =
+  ## Adjoint of projectUHVP with respect to dc (chain tangent).
+  projectUHVPVJP_dc(dcbar[], u[], x[], c[], rbar[])
+template projectUHVPVJP_dc*(dcbar: var Color, x, c, rbar: Color) =
+  ## Adjoint of projectUHVP with respect to dc (convenience wrapper).
+  projectUHVPVJP_dc(dcbar[], x[], c[], rbar[])
 template projectSU*(r: var Color) =
   projectSU(r[])
 template projectSU*(r: var Color, x: Color2) =
@@ -287,3 +329,6 @@ template im*(x: Color): untyped = asColor(im(x[]))
 template exp*(x: Color): untyped = asColor(exp(x[]))
 template expDeriv*(x: Color, c: Color2): untyped = asColor(expDeriv(x[], c[]))
 template ln*(x: Color): untyped = asColor(ln(x[]))
+template sylsolve*(r: var Color, y: Color2, b: Color3) =
+  ## Solve Sylvester equation: Y R + R Y = B
+  sylsolve(r[], y[], b[])
diff --git a/tests/deriv/tgaugeaction.nim b/tests/deriv/tgaugeaction.nim
new file mode 100644
index 00000000..297ef98d
--- /dev/null
+++ b/tests/deriv/tgaugeaction.nim
@@ -0,0 +1,164 @@
+import qex, physics/qcdTypes, gauge/gaugeAction, gauge/gaugeUtils
+import ./utils
+
+qexInit()
+
+var env = initGaugeTestEnv()
+let lo = env.lo
+
+type
+  GaugeField = typeof(env.g)
+  ContractProjectTAHInput = Pair[GaugeField, GaugeField]
+  ContractProjectTAHDir = Pair[GaugeField, GaugeField]
+  ContractProjectTAHScalarBase = Pair[ContractProjectTAHInput, GaugeField]
+
+let gc = GaugeActionCoeffs(plaq:6.0)
+echo "S(g): ", gc.gaugeAction1(env.g)
+
+proc randomLinearField(): GaugeField =
+  var x = lo.newGauge
+  x.gaussian env.r
+  x
+
+proc addLinearPerturb(dst: var GaugeField; x, dx: GaugeField; eps: float) =
+  let d = cast[ptr cArray[type(dst[0])]](unsafeAddr(dst[0]))
+  let xx = cast[ptr cArray[type(x[0])]](unsafeAddr(x[0]))
+  let dd = cast[ptr cArray[type(dx[0])]](unsafeAddr(dx[0]))
+  let nd = dst.len
+  threads:
+    for mu in 0..<nd:
+      d[mu] := xx[mu]
+      d[mu] += eps * dd[mu]
+
+proc perturbContractProjectTAH(
+    x: ContractProjectTAHInput;
+    dx: ContractProjectTAHDir;
+    eps: float;
+    res: var ContractProjectTAHInput
+  ) =
+  addLinearPerturb(res.a, x.a, dx.a, eps)
+  addLinearPerturb(res.b, x.b, dx.b, eps)
+
+proc perturbContractProjectTAHScalar(
+    x: ContractProjectTAHScalarBase;
+    dx: ContractProjectTAHDir;
+    eps: float;
+    res: var ContractProjectTAHScalarBase
+  ) =
+  perturbContractProjectTAH(x.a, dx, eps, res.a)
+  copyLike(res.b, x.b)
+
+proc contractProjectTAHForward(res: var GaugeField; x: ContractProjectTAHInput) =
+  copyLike(res, x.b)
+  contractProjectTAH(x.a, res)
+
+proc contractProjectTAHScalarForward(x: ContractProjectTAHScalarBase): float =
+  var y = lo.newGauge
+  contractProjectTAHForward(y, x.a)
+  dotLike(x.b, y)
+
+proc contractProjectTAHJVP(
+    x: ContractProjectTAHInput;
+    dx: ContractProjectTAHDir;
+    res: var GaugeField
+  ) =
+  mixin adj
+  let g = cast[ptr cArray[type(x.a[0])]](unsafeAddr(x.a[0]))
+  let d = cast[ptr cArray[type(x.b[0])]](unsafeAddr(x.b[0]))
+  let dg = cast[ptr cArray[type(dx.a[0])]](unsafeAddr(dx.a[0]))
+  let dd = cast[ptr cArray[type(dx.b[0])]](unsafeAddr(dx.b[0]))
+  let r = cast[ptr cArray[type(res[0])]](unsafeAddr(res[0]))
+  let nd = res.len
+  threads:
+    for mu in 0..<nd:
+      for e in r[mu]:
+        var s {.noInit.}: type(r[mu][e])
+        s := dg[mu][e] * d[mu][e].adj
+        s += g[mu][e] * dd[mu][e].adj
+        r[mu][e].projectTAH s
+
+proc contractProjectTAHAdjoint(
+    x: ContractProjectTAHInput;
+    ybar: GaugeField;
+    res: var ContractProjectTAHDir
+  ) =
+  contractProjectTAHVJP(x.a, x.b, ybar, res.b, res.a)
+
+proc contractProjectTAHScalarJVP(
+    x: ContractProjectTAHScalarBase;
+    dx: ContractProjectTAHDir;
+    res: var float
+  ) =
+  var dbar = lo.newGauge
+  var gbar = lo.newGauge
+  contractProjectTAHVJP(x.a.a, x.a.b, x.b, dbar, gbar)
+  res = dotLike(gbar, dx.a) + dotLike(dbar, dx.b)
+
+proc randomContractProjectTAHInput(): ContractProjectTAHInput =
+  makePair(env.g, randomLinearField())
+
+proc randomContractProjectTAHDir(): ContractProjectTAHDir =
+  makePair(randomLinearField(), randomLinearField())
+
+proc randomContractProjectTAHScalarBase(): ContractProjectTAHScalarBase =
+  makePair(randomContractProjectTAHInput(), randomLinearField())
+
+proc testContractProjectTAHVJPFD(): int =
+  let cfg = initTestConfig(
+    name = "contractProjectTAHVJP FD",
+    samples = 5,
+    eps = 1e-2,
+    scale = 2.0,
+    atol = 1e-7,
+    rtol = 1e-6,
+    fdFactor = 3.0,
+    verbose = true
+  )
+  let res = runFDScalarJVP(
+    cfg = cfg,
+    makeBase = proc(sample: int): ContractProjectTAHScalarBase =
+      randomContractProjectTAHScalarBase(),
+    makeDir = proc(sample: int; x: ContractProjectTAHScalarBase): ContractProjectTAHDir =
+      randomContractProjectTAHDir(),
+    perturb = perturbContractProjectTAHScalar,
+    f = contractProjectTAHScalarForward,
+    jvp = contractProjectTAHScalarJVP
+  )
+  result = res.failed
+
+proc testContractProjectTAHVJPAdjoint(): int =
+  let cfg = initTestConfig(
+    name = "contractProjectTAHVJP adjoint identity",
+    samples = 5,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): ContractProjectTAHInput =
+      randomContractProjectTAHInput(),
+    makeDir = proc(sample: int; x: ContractProjectTAHInput): ContractProjectTAHDir =
+      randomContractProjectTAHDir(),
+    jvp = contractProjectTAHJVP,
+    vjp = contractProjectTAHAdjoint
+  )
+  result = res.failed
+
+var fail = 0
+# Section A: baseline FD
+fail += runGaugeActionForceFD(
+  env,
+  action = proc(g: GaugeField): float =
+    gc.gaugeAction1(g),
+  deriv = proc(g: GaugeField; f: GaugeField) =
+    gc.gaugeForce(g, f),
+  cfg = actionForceCfgDefault("gaugeAction1/gaugeForce")
+).failed
+fail += testContractProjectTAHVJPFD()
+fail += testContractProjectTAHVJPAdjoint()
+
+if fail==0:
+  qexFinalize()
+else:
+  qexAbort(fail)
diff --git a/tests/deriv/thyp.nim b/tests/deriv/thyp.nim
new file mode 100644
index 00000000..d1f3199c
--- /dev/null
+++ b/tests/deriv/thyp.nim
@@ -0,0 +1,963 @@
+import qex, physics/qcdTypes, algorithms/numdiff, gauge/hypsmear, gauge/gaugeAction, gauge/smearutil
+import maths/matrixFunctions
+import ./utils
+
+qexInit()
+
+var env = initGaugeTestEnv()
+let lo = env.lo
+var g = env.g
+var r = env.r
+
+type
+  GaugeField = typeof(g)
+
+proc makeChain(): GaugeField =
+  var c = lo.newGauge
+  c.randomTAH r
+  c
+
+proc makeDir(): GaugeField =
+  var d = lo.newGauge
+  d.randomTAH r
+  d
+
+proc makeProbe(): GaugeField =
+  var p = lo.newGauge
+  p.gaussian r
+  p
+
+var coef = HypCoefs(alpha1:0.4, alpha2:0.5, alpha3:0.5)
+var info = PerfInfo()
+
+let gc = GaugeActionCoeffs(plaq:6.0)
+
+let adjCoefCombos = [
+  HypCoefs(alpha1:0.0, alpha2:0.0, alpha3:0.0),  # 0: All off
+  HypCoefs(alpha1:0.4, alpha2:0.0, alpha3:0.0),  # 1: Only L1
+  HypCoefs(alpha1:0.0, alpha2:0.5, alpha3:0.0),  # 2: Only L2
+  HypCoefs(alpha1:0.0, alpha2:0.0, alpha3:0.5),  # 3: Only L3
+  HypCoefs(alpha1:0.4, alpha2:0.5, alpha3:0.0),  # 4: L1+L2
+  HypCoefs(alpha1:0.4, alpha2:0.0, alpha3:0.5),  # 5: L1+L3
+  HypCoefs(alpha1:0.0, alpha2:0.5, alpha3:0.5),  # 6: L2+L3
+  HypCoefs(alpha1:0.4, alpha2:0.5, alpha3:0.5),  # 7: All on
+]
+
+let adjCoefNames = [
+  "All off (trivial)",
+  "Only L1",
+  "Only L2",
+  "Only L3",
+  "L1+L2",
+  "L1+L3",
+  "L2+L3",
+  "All on",
+]
+
+echo "S(g): ", gc.gaugeAction1(g)
+
+# Production hypsmear using closure-based derivative
+
+proc hypAction(g:auto):auto =
+  var sg = lo.newGauge
+  coef.smear(g, sg)
+  gc.gaugeAction1(sg)
+
+proc hypForce(g:auto, f:auto) =
+  var sg = lo.newGauge
+  var ds = lo.newGauge
+  var fn = coef.smearGetForce(g, sg, info)
+  gc.gaugeActionDeriv(sg, ds)
+  fn(f, ds)
+  contractProjectTAH(g, f)
+
+# Preallocated hypsmear environment derivative
+
+proc hypActionPrealloc(g:auto):auto =
+  var sg = lo.newGauge
+  var hs = lo.newHypSmear(coef)
+  hs.smear(g, sg)
+  gc.gaugeAction1(sg)
+
+proc hypForcePrealloc(g:auto, f:auto) =
+  var sg = lo.newGauge
+  var ds = lo.newGauge
+  var hs = lo.newHypSmear(coef)
+  hs.smear(g, sg)
+  gc.gaugeActionDeriv(sg, ds)
+  hs.smearVJP(f, ds)
+  contractProjectTAH(g, f)
+
+proc testSmearForceConsistency(): int =
+  let cfg = initTestConfig(
+    name = "smearGetForce/prealloc consistency",
+    samples = 1,
+    atol = 1e-14,
+    rtol = 1e-12,
+    verbose = true
+  )
+  var sgClosure = lo.newGauge
+  var sgPrealloc = lo.newGauge
+  var chain = lo.newGauge
+  var fClosure = lo.newGauge
+  var fPrealloc = lo.newGauge
+  var diff = lo.newGauge
+  var hs = lo.newHypSmear(coef)
+  var fn = coef.smearGetForce(g, sgClosure, info)
+
+  hs.smear(g, sgPrealloc)
+  gc.gaugeActionDeriv(sgClosure, chain)
+  fn(fClosure, chain)
+  gc.gaugeActionDeriv(sgPrealloc, chain)
+  hs.smearVJP(fPrealloc, chain)
+  contractProjectTAH(g, fClosure)
+  contractProjectTAH(g, fPrealloc)
+
+  threads:
+    for mu in 0..<4:
+      diff[mu] := sgPrealloc[mu] - sgClosure[mu]
+  let smearRel = sqrt(norm2Like(diff) / max(norm2Like(sgClosure), 1e-30))
+
+  threads:
+    for mu in 0..<4:
+      diff[mu] := fPrealloc[mu] - fClosure[mu]
+  let forceRel = sqrt(norm2Like(diff) / max(norm2Like(fClosure), 1e-30))
+
+  let smearOk = reportCompare(cfg, 0, smearRel, 0.0, "smear output rel diff")
+  let forceOk = reportCompare(cfg, 0, forceRel, 0.0, "force rel diff")
+  if not (smearOk and forceOk):
+    result = 1
+
+proc restoreHypState(hs: var auto; sg: GaugeField) =
+  hs.smear(g, sg)
+
+proc primeHypReverse(hs: var auto; sg, deriv: GaugeField; chain: GaugeField) =
+  restoreHypState(hs, sg)
+  hs.smearVJP(deriv, chain)
+
+template contractedForceJvp(hs, x, forcebar, chain, dg: untyped;
+                            dchain: untyped = @[]): untyped =
+  ## Compose the clean uncontracted `smearHVP` with the outer
+  ## `contractProjectTAH(x, ·)` derivative.
+  block:
+    var sg = lo.newGauge
+    hs.smear(x, sg)
+
+    var deriv = lo.newGauge
+    hs.smearVJP(deriv, chain)
+
+    # `smearVJP` reuses reverse scratch, so rebuild the cached forward state
+    # before evaluating the uncontracted HVP.
+    hs.smear(x, sg)
+
+    var dderiv = lo.newGauge
+    hs.smearHVP(dderiv, chain, dg, dchain)
+
+    var derivbar = lo.newGauge
+    var gbarContract = lo.newGauge
+    contractProjectTAHVJP(x, deriv, forcebar, derivbar, gbarContract)
+
+    var dgEff = lo.newGauge
+    threads:
+      for mu in 0..<4:
+        dgEff[mu] := dg[mu] * x[mu]
+
+    dotLike(derivbar, dderiv) + dotLike(gbarContract, dgEff)
+
+proc runSmearHVPCase(name: string; samples: int): int =
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  hs.smear(g, sg)
+  let chain = makeChain()
+  let cfg = initTestConfig(
+    name = name,
+    samples = samples,
+    eps = 1e-2,
+    atol = 1e-6,
+    rtol = 1e-6,
+    verbose = true
+  )
+  let res = runGaugeHVPFD(
+    env,
+    grad = proc(x: GaugeField; res: var GaugeField) =
+      var sg2 = lo.newGauge
+      hs.smear(x, sg2)
+      hs.smearVJP(res, chain),
+    hvp = proc(x: GaugeField; dx: GaugeField; res: var GaugeField) =
+      hs.smear(x, sg)
+      hs.smearHVP(res, chain, dx),
+    cfg = cfg
+  )
+  res.failed
+
+proc testSmearDeriv2(): int =
+  result = runSmearHVPCase(
+    name = "smearHVP (uncontracted HYP second derivative)",
+    samples = 5
+  )
+
+## Level isolation tests for debugging smearHVP
+## Test with different alpha coefficients to isolate which level has the bug
+proc testSmearDeriv2Level(levelName: string, testCoef: HypCoefs): int =
+  var hsTest = lo.newHypSmear(testCoef)
+  var sgTest = lo.newGauge
+  hsTest.smear(g, sgTest)
+  let chainTest = makeChain()
+  let cfg = initTestConfig(
+    name = "smearHVP: " & levelName,
+    samples = 3,
+    eps = 1e-2,
+    scale = 2.0,
+    atol = 1e-6,
+    rtol = 1e-6,
+    fdFactor = 3.0,
+    verbose = true
+  )
+  let res = runGaugeHVPFD(
+    env,
+    grad = proc(x: GaugeField; res: var GaugeField) =
+      var sg2 = lo.newGauge
+      hsTest.smear(x, sg2)
+      hsTest.smearVJP(res, chainTest),
+    hvp = proc(x: GaugeField; dx: GaugeField; res: var GaugeField) =
+      hsTest.smear(x, sgTest)
+      hsTest.smearHVP(res, chainTest, dx),
+    cfg = cfg
+  )
+  result = res.failed
+
+proc testGradForceFullChain(): int =
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  hs.smear(g, sg)
+
+  var p = makeDir()
+
+  let cfg = initTestConfig(
+    name = "grad <p, force(g)> (full chain)",
+    samples = 5,
+    eps = 1e-2,
+    scale = 2.0,
+    atol = 1e-5,
+    rtol = 1e-5,
+    fdFactor = 3.0,
+    verbose = true
+  )
+
+  let res = runFDScalarJVPDefault(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField =
+      g,
+    makeDir = proc(sample: int; x: GaugeField): GaugeField =
+      var dg = lo.newGauge
+      dg.randomTAH r
+      dg,
+    f = proc(x: GaugeField): float =
+      var hsx = lo.newHypSmear(coef)
+      var sgx = lo.newGauge
+      hsx.smear(x, sgx)
+      var chain = lo.newGauge
+      gc.gaugeActionDeriv(sgx, chain)
+      var force = lo.newGauge
+      hsx.smearVJP(force, chain)
+      contractProjectTAH(x, force)
+      var s = 0.0
+      for mu in 0..<4:
+        s += redot(p[mu], force[mu])
+      s,
+    jvp = proc(x: GaugeField; dx: GaugeField): float =
+      hs.smear(x, sg)
+      var chain0 = lo.newGauge
+      gc.gaugeActionDeriv(sg, chain0)
+      var dsg = lo.newGauge
+      hs.smearJVP(dsg, dx, sg)
+      var dchain = lo.newGauge
+      threads:
+        for mu in 0..<4:
+          dchain[mu] := 0
+      gc.gaugeDerivDeriv2(sg, dsg, dchain)
+      threads:
+        for mu in 0..<4:
+          dchain[mu] := -1.0 * dchain[mu]
+      contractedForceJvp(hs, x, p, chain0, dx, dchain)
+  )
+  result = res.failed
+
+## Test: smearJVP alone (compare against FD of smear output)
+
+proc testSmearTangent(): int =
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  let mkProbe = makeProbe
+  let cfg = initTestConfig(
+    name = "smearJVP (forward tangent of HYP smearing)",
+    samples = 3,
+    eps = 1e-2,
+    scale = 2.0,
+    atol = 1e-5,
+    rtol = 1e-5,
+    fdFactor = 3.0,
+    verbose = true
+  )
+  let res = runGaugeJVPFD(
+    env = env,
+    f = proc(x: GaugeField; res: var GaugeField) =
+      hs.smear(x, res),
+    jvp = proc(x: GaugeField; dx: GaugeField; res: var GaugeField) =
+      hs.smear(x, sg)
+      hs.smearJVP(res, dx, sg),
+    cfg = cfg,
+    makeProbe = proc(sample: int; x: GaugeField): GaugeField =
+      mkProbe()
+  )
+  result = res.failed
+
+## Test: gaugeDerivDeriv2 alone (verify it computes d/dε[gaugeActionDeriv(g+ε·h)])
+
+proc testGaugeDerivDeriv2(): int =
+  var probe = makeProbe()
+  let mkProbe = makeProbe
+  let cfg = initTestConfig(
+    name = "gaugeDerivDeriv2 (second derivative of gauge action)",
+    samples = 3,
+    eps = 1e-2,
+    scale = 2.0,
+    atol = 1e-5,
+    rtol = 1e-4,
+    fdFactor = 3.0,
+    verbose = true
+  )
+  let res = runGaugeJVPFD(
+    env = env,
+    f = proc(x: GaugeField; res: var GaugeField) =
+      gc.gaugeActionDeriv(x, res),
+    jvp = proc(x: GaugeField; dx: GaugeField; res: var GaugeField) =
+      var dgEff = lo.newGauge
+      let resPtr = cast[ptr GaugeField](unsafeAddr(res))
+      threads:
+        for mu in 0..<4:
+          dgEff[mu] := dx[mu] * x[mu]
+          resPtr[][mu] := 0
+      gc.gaugeDerivDeriv2(x, dgEff, res)
+      threads:
+        for mu in 0..<4:
+          resPtr[][mu] := -resPtr[][mu],
+    cfg = cfg,
+    makeProbe = proc(sample: int; x: GaugeField): GaugeField =
+      mkProbe()
+  )
+  result = res.failed
+
+## Test: Fixed-chain contracted force directional derivative.
+## This keeps a scalar sanity check for the outer contraction while the HYP API
+## itself stays uncontracted.
+
+proc testSmearDeriv2FixedChain(): int =
+  var hs = lo.newHypSmear(coef)
+  let chain = makeChain()
+
+  let p = makeDir()
+
+  let cfg = initTestConfig(
+    name = "smearHVP fixed chain (sanity check)",
+    samples = 3,
+    eps = 1e-2,
+    scale = 2.0,
+    atol = 1e-5,
+    rtol = 1e-5,
+    fdFactor = 3.0,
+    verbose = true
+  )
+  let res = runFDScalarJVPDefault(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField =
+      g,
+    makeDir = proc(sample: int; x: GaugeField): GaugeField =
+      var dg = lo.newGauge
+      dg.randomTAH r
+      dg,
+    f = proc(x: GaugeField): float =
+      var hsx = lo.newHypSmear(coef)
+      var sgx = lo.newGauge
+      hsx.smear(x, sgx)
+      var force = lo.newGauge
+      hsx.smearVJP(force, chain)
+      contractProjectTAH(x, force)
+      var s = 0.0
+      for mu in 0..<4:
+        s += redot(p[mu], force[mu])
+      s,
+    jvp = proc(x: GaugeField; dx: GaugeField): float =
+      contractedForceJvp(hs, x, p, chain, dx)
+  )
+  result = res.failed
+
+## Test: Adjoint identity for smearJVP/smearVJP
+## Verifies: <probe, smearJVP(dg)> = <smearVJP(probe), dg*g>
+
+proc testSmearTangentAdjoint(): int =
+  let cfg = initTestConfig(
+    name = "smearJVP/smearVJP adjoint identity",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField =
+      g,
+    makeDir = proc(sample: int; x: GaugeField): GaugeField =
+      var dg = lo.newGauge
+      dg.randomTAH r
+      dg,
+    jvp = proc(x: GaugeField; dx: GaugeField; res: var GaugeField) =
+      var dg = lo.newGauge
+      for mu in 0..<4:
+        dg[mu] := dx[mu] * x[mu].adj
+      hs.smear(x, sg)
+      hs.smearJVP(res, dg, sg),
+    vjp = proc(x: GaugeField; ybar: GaugeField; res: var GaugeField) =
+      hs.smear(x, sg)
+      hs.smearVJP(res, ybar)
+  )
+  result = res.failed
+
+## Test: Adjoint identity for smearVJP w.r.t. chain
+## Verifies: <derivbar, smearVJP(g, chain)> = <smearVJPChain(derivbar), chain>
+
+proc testSmearDerivAdjChain(): int =
+  let cfg = initTestConfig(
+    name = "smearVJPChain adjoint identity",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  hs.smear(g, sg)
+  let res = runGaugeAdjointIdentity(
+    env,
+    jvp = proc(x: GaugeField; dx: GaugeField; res: var GaugeField) =
+      hs.smear(x, sg)  # ensure internal state is current
+      hs.smearVJP(res, dx),
+    vjp = proc(x: GaugeField; ybar: GaugeField; res: var GaugeField) =
+      hs.smear(x, sg)
+      hs.smearVJPChain(res, ybar),
+    cfg = cfg,
+    makeDir = proc(sample: int; x: GaugeField): GaugeField =
+      var chain = lo.newGauge
+      chain.gaussian r
+      chain,
+  )
+  result = res.failed
+
+## Test: Pure reverse-mode gradient for <p, force(g)>
+## This test verifies the full reverse-mode chain:
+##   T(g) = <p, contractProjectTAH(g, smearVJP(g, gaugeActionDeriv(smear(g))))>
+## Using only backward propagation (adjoint operations).
+##
+## The pure reverse-mode chain is:
+##   Forward: sg = smear(g), chain = gaugeActionDeriv(sg), deriv = smearVJP(chain)
+##   Backward: forcebar = p
+##             (derivbar, gbar_contract) = contractProjectTAHVJP(g, deriv, forcebar)
+##             chainbar = smearVJPChain(derivbar)
+##             sgbar = gaugeActionDeriv_adj(chainbar)  [self-adjoint structure]
+##             gbar = smearVJP(sgbar)  [by smearJVP/smearVJP duality]
+##   Gradient: <gbar, dg*g>
+
+proc testGradForceReverseModeWithCoef(testCoef: HypCoefs): TestResult =
+  ## Test pure reverse mode with a specific coefficient set.
+  var summary = TestResult(name: "pure reverse-mode FD")
+  let eps = 1e-2
+
+  var hs = lo.newHypSmear(testCoef)
+  var sg = lo.newGauge
+  hs.smear(g, sg)
+
+  var p = makeDir()
+
+  let cfgFD = initTestConfig(
+    name = "pure reverse-mode FD",
+    samples = 1,
+    eps = eps,
+    scale = 2.0,
+    atol = 1e-5,
+    rtol = 1e-5,
+    fdFactor = 3.0,
+    verbose = false
+  )
+  let cfgPure = initTestConfig(
+    name = "Pure vs FoR",
+    samples = 1,
+    atol = 1e-8,
+    rtol = 1e-8,
+    verbose = false
+  )
+
+  for n in 0..<3:
+    var dg = makeDir()
+
+    var fd, fde: float
+    var sAnaFoR = 0.0
+    discard runFDScalarJVPDefault(
+      cfg = cfgFD,
+      makeBase = proc(sample: int): GaugeField =
+        g,
+      makeDir = proc(sample: int; x: GaugeField): GaugeField =
+        dg,
+      f = proc(x: GaugeField): float =
+        var hsx = lo.newHypSmear(testCoef)
+        var sgx = lo.newGauge
+        hsx.smear(x, sgx)
+        var chain = lo.newGauge
+        gc.gaugeActionDeriv(sgx, chain)
+        var force = lo.newGauge
+        hsx.smearVJP(force, chain)
+        contractProjectTAH(x, force)
+        var s = 0.0
+        for mu in 0..<4:
+          s += redot(p[mu], force[mu])
+        s,
+      jvp = proc(x: GaugeField; dx: GaugeField): float =
+        hs.smear(x, sg)
+        var chain0 = lo.newGauge
+        gc.gaugeActionDeriv(sg, chain0)
+
+        var dsg = lo.newGauge
+        hs.smearJVP(dsg, dx, sg)
+
+        var dchain = lo.newGauge
+        threads:
+          for mu in 0..<4:
+            dchain[mu] := 0
+        gc.gaugeDerivDeriv2(sg, dsg, dchain)
+        threads:
+          for mu in 0..<4:
+            dchain[mu] := -1.0 * dchain[mu]
+        sAnaFoR = contractedForceJvp(hs, x, p, chain0, dx, dchain)
+        sAnaFoR,
+      accept = captureFD(addr fd, addr fde)
+    )
+
+    # ========== PURE REVERSE MODE ==========
+    # Forward pass:
+    restoreHypState(hs, sg)
+    var chain = lo.newGauge
+    gc.gaugeActionDeriv(sg, chain)
+    var deriv = lo.newGauge
+    hs.smearVJP(deriv, chain)
+    # Note: deriv is pre-contraction; force = contractProjectTAH(g, deriv)
+
+    # Backward pass:
+    # Step 1: contractProjectTAHVJP gives both the adjoint w.r.t. the
+    # pre-contraction force (`derivbar`) and the direct gauge contribution
+    # from differentiating the outer contraction itself (`gbar_contract`).
+    var derivbar = lo.newGauge
+    var gbar_contract = lo.newGauge
+    contractProjectTAHVJP(g, deriv, p, derivbar, gbar_contract)
+
+    # Step 2: chainbar = smearVJPChain(derivbar)
+    restoreHypState(hs, sg)
+    var chainbar = lo.newGauge
+    hs.smearVJPChain(chainbar, derivbar)
+
+    # Step 2b: gbar_internal = smearHVPVJP(derivbar, chain)
+    # This captures the contribution from internal HYP state dependence.
+    restoreHypState(hs, sg)
+    var gbar_internal = lo.newGauge
+    hs.smearHVPVJP(gbar_internal, derivbar, chain)
+
+    # Step 3: sgbar = adjoint of (sg → gaugeActionDeriv(sg)) applied to chainbar
+    # For plaquette action, the Hessian is symmetric, so:
+    #   <chainbar, gaugeDerivDeriv2(sg, dsg)> = <gaugeDerivDeriv2(sg, chainbar), dsg>
+    # Thus sgbar = gaugeDerivDeriv2(sg, chainbar)
+    var sgbar = lo.newGauge
+    threads:
+      for mu in 0..<4:
+        sgbar[mu] := 0
+    gc.gaugeDerivDeriv2(sg, chainbar, sgbar)
+    # Negate due to force sign convention
+    threads:
+      for mu in 0..<4:
+        sgbar[mu] := -1.0 * sgbar[mu]
+
+    # Step 4: gbar_chain = smearJVP_adj(sgbar) = smearVJP(sgbar)
+    # From testSmearTangentAdjoint: <probe, smearJVP(dg, sg)> = <smearVJP(probe), dg*g>
+    # So smearJVP† = smearVJP in the appropriate sense.
+    restoreHypState(hs, sg)
+    var gbar_chain = lo.newGauge
+    hs.smearVJP(gbar_chain, sgbar)
+
+    # Step 6: gbar = gbar_chain + gbar_internal + gbar_contract
+    var gbar = lo.newGauge
+    threads:
+      for mu in 0..<4:
+        gbar[mu] := gbar_chain[mu] + gbar_internal[mu] + gbar_contract[mu]
+
+    # Compute gradient: <gbar, dg*g>
+    var dgEff = lo.newGauge
+    threads:
+      for mu in 0..<4:
+        dgEff[mu] := dg[mu] * g[mu]
+
+    var sAnaPure = 0.0
+    for mu in 0..<4:
+      sAnaPure += redot(gbar[mu], dgEff[mu])
+
+    # Compare FoR with FD (always should pass)
+    let errFoR = abs(sAnaFoR - fd)
+    let refVal = max(1.0, abs(fd))
+    let okFoR = acceptTol(cfgFD, errFoR, fde, refVal)
+    let errPure = abs(sAnaPure - sAnaFoR)
+    let refPure = max(1.0, max(abs(sAnaPure), abs(sAnaFoR)))
+    let relPure = errPure / refPure
+    let okPure = errPure <= max(cfgPure.atol, cfgPure.rtol * refPure)
+    echo "    sample ", n,
+         " | FoR vs FD: ", (if okFoR: "PASS" else: "FAIL"),
+         " (err=", errFoR, ", fdErr=", fde, ")",
+         " | Pure vs FoR: ", (if okPure: "PASS" else: "FAIL"),
+         " (err=", errPure, ", rel=", relPure, ")"
+    if okFoR: inc summary.passed else: inc summary.failed
+
+    if okPure: inc summary.passed else: inc summary.failed
+
+  result = summary
+
+
+proc testGradForceReverseMode(): int =
+  echo "Testing all 8 coefficient combinations to isolate bugs...\n"
+
+  var labels: seq[string] = @[]
+  for idx in 0..<adjCoefCombos.len:
+    let testCoef = adjCoefCombos[idx]
+    let l1 = if testCoef.alpha1 > 0: "+" else: "0"
+    let l2 = if testCoef.alpha2 > 0: "+" else: "0"
+    let l3 = if testCoef.alpha3 > 0: "+" else: "0"
+    labels.add("(L1=" & l1 & " L2=" & l2 & " L3=" & l3 & ") " & adjCoefNames[idx])
+
+  let summary = runCoefSweep(
+    name = "pure reverse-mode gradient for <p, force(g)>",
+    coefs = adjCoefCombos,
+    labels = labels,
+    runOne = proc(testCoef: HypCoefs): TestResult =
+      testGradForceReverseModeWithCoef(testCoef)
+  )
+  result = summary.failed
+
+## Minimal test for dgEff conversion: dgEff = dg * g, gbar = dgEffbar * g†
+proc testDgEffConversion(): int =
+  let cfg = initTestConfig(
+    name = "dgEff ↔ gbar conversion",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField =
+      g,
+    makeDir = proc(sample: int; x: GaugeField): GaugeField =
+      var dg = lo.newGauge
+      dg.gaussian r
+      dg,
+    jvp = proc(x: GaugeField; dx: GaugeField; res: var GaugeField) =
+      for mu in 0..<4:
+        res[mu] := dx[mu] * x[mu],
+    vjp = proc(x: GaugeField; ybar: GaugeField; res: var GaugeField) =
+      for mu in 0..<4:
+        res[mu] := ybar[mu] * x[mu].adj
+  )
+  result = res.failed
+
+## Test that the direct contribution adjoint is correct
+## Forward: dderiv = ma * dflx, Adjoint: dflxbar = ma * derivbar
+proc testDirectContribution(): int =
+  let cfg = initTestConfig(
+    name = "direct contribution (scaling)",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let ma = 0.6
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): int =
+      0,
+    makeDir = proc(sample: int; x: int): GaugeField =
+      var dflx = lo.newGauge
+      dflx.gaussian r
+      dflx,
+    jvp = proc(x: int; dx: GaugeField; res: var GaugeField) =
+      for mu in 0..<4:
+        res[mu] := ma * dx[mu],
+    vjp = proc(x: int; ybar: GaugeField; res: var GaugeField) =
+      for mu in 0..<4:
+        res[mu] := ma * ybar[mu]
+  )
+  result = res.failed
+
+proc testSmearDeriv2AdjInternal(coef: HypCoefs): int =
+  ## Test internal adjoint for smearHVPVJP with a specific coefficient set.
+  let cfg = initTestConfig(
+    name = "smearHVPVJP adjoint identity (internal)",
+    samples = 3,
+    atol = 1e-10,
+    rtol = 1e-8,
+    verbose = true
+  )
+
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  var deriv0 = lo.newGauge
+
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField =
+      var chain = lo.newGauge
+      chain.randomTAH r
+      chain,
+    makeDir = proc(sample: int; x: GaugeField): GaugeField =
+      var dg = lo.newGauge
+      dg.randomTAH r
+      dg,
+    jvp = proc(x: GaugeField; dx: GaugeField; res: var GaugeField) =
+      var dg = lo.newGauge
+      for mu in 0..<4:
+        dg[mu] := dx[mu] * g[mu].adj
+      primeHypReverse(hs, sg, deriv0, x)
+      hs.smearHVP(res, x, dg),
+    vjp = proc(x: GaugeField; ybar: GaugeField; res: var GaugeField) =
+      primeHypReverse(hs, sg, deriv0, x)
+      hs.smearHVPVJP(res, ybar, x)
+  )
+  result = res.failed
+
+proc testLevel3Direct(): int =
+  let cfg = initTestConfig(
+    name = "Level 3 direct contribution",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+
+  let ma3 = 1 - coef.alpha3
+
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  hs.smear(g, sg)
+  let flx = hs.state.flx
+
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField =
+      var chain = lo.newGauge
+      chain.gaussian r
+      chain,
+    makeDir = proc(sample: int; x: GaugeField): GaugeField =
+      var dgEff = lo.newGauge
+      dgEff.gaussian r
+      dgEff,
+    jvp = proc(x: GaugeField; dx: GaugeField; res: var GaugeField) =
+      var dflx = lo.newGauge
+      threads:
+        for mu in 0..<4:
+          dflx[mu] := ma3 * dx[mu]
+      var dfc = lo.newGauge
+      threads:
+        for mu in 0..<4:
+          for i in dfc[mu]:
+            dfc[mu][i].projectUHVP(flx[mu][i], x[mu][i], dflx[mu][i])
+      let resPtr = cast[ptr GaugeField](unsafeAddr(res))
+      threads:
+        for mu in 0..<4:
+          resPtr[][mu] := ma3 * dfc[mu],
+    vjp = proc(x: GaugeField; ybar: GaugeField; res: var GaugeField) =
+      var dfcbar = lo.newGauge
+      threads:
+        for mu in 0..<4:
+          dfcbar[mu] := ma3 * ybar[mu]
+      var dflxbar = lo.newGauge
+      threads:
+        for mu in 0..<4:
+          for i in dflxbar[mu]:
+            dflxbar[mu][i].projectUHVPVJP_dx(flx[mu][i], x[mu][i], dfcbar[mu][i])
+      let resPtr = cast[ptr GaugeField](unsafeAddr(res))
+      threads:
+        for mu in 0..<4:
+          resPtr[][mu] := ma3 * dflxbar[mu]
+  )
+  result = res.failed
+
+proc testLevel2Projection(): int =
+  let cfg = initTestConfig(
+    name = "Level 2 projections only",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  hs.smear(g, sg)
+
+  type Fld = type(g[0])
+  let l2x = hs.state.l2x
+  var l2: typeof(hs.state.l2x)
+  when compiles(hs.state.l2):
+    l2 = hs.state.l2
+  else:
+    l2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+    threads:
+      for mu in 0..<4:
+        for nu in 0..<4:
+          if nu != mu:
+            for e in l2[mu,nu]:
+              l2[mu,nu][e].projectU l2x[mu,nu][e]
+  var chain0L2 = newOneOf(l2x)
+  threads:
+    for mu in 0..<4:
+      for nu in 0..<4:
+        if nu != mu:
+          chain0L2[mu,nu].gaussian r
+
+  type FA = typeof(l2x)
+  type Y = Pair[FA, FA]
+
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): int =
+      0,
+    makeDir = proc(sample: int; x: int): FA =
+      var dl2x = newOneOf(l2x)
+      threads:
+        for mu in 0..<4:
+          for nu in 0..<4:
+            if nu != mu:
+              dl2x[mu,nu].gaussian r
+      dl2x,
+    jvp = proc(x: int; dx: FA; res: var Y) =
+      var dl2 = newOneOf(dx)
+      var dfl2 = newOneOf(dx)
+      threads:
+        for mu in 0..<4:
+          for nu in 0..<4:
+            if nu != mu:
+              for i in dl2[mu,nu]:
+                dl2[mu,nu][i].projectUJVP(l2[mu,nu][i], l2x[mu,nu][i], dx[mu,nu][i])
+      threads:
+        for mu in 0..<4:
+          for nu in 0..<4:
+            if nu != mu:
+              for i in dfl2[mu,nu]:
+                dfl2[mu,nu][i].projectUHVPu(l2[mu,nu][i], l2x[mu,nu][i], chain0L2[mu,nu][i], dx[mu,nu][i])
+      res.a := dfl2
+      res.b := dl2,
+    vjp = proc(x: int; ybar: Y; res: var FA) =
+      var dl2xbar = newOneOf(l2x)
+      threads:
+        for mu in 0..<4:
+          for nu in 0..<4:
+            if nu != mu:
+              var tmp {.noinit.}: type(dl2xbar[mu,nu][0])
+              for i in dl2xbar[mu,nu]:
+                tmp.projectUVJP(l2[mu,nu][i], l2x[mu,nu][i], ybar.b[mu,nu][i])
+                dl2xbar[mu,nu][i] := tmp
+      threads:
+        for mu in 0..<4:
+          for nu in 0..<4:
+            if nu != mu:
+              var tmp {.noinit.}: type(dl2xbar[mu,nu][0])
+              for i in dl2xbar[mu,nu]:
+                tmp.projectUHVPVJP_dx(l2[mu,nu][i], l2x[mu,nu][i], chain0L2[mu,nu][i], ybar.a[mu,nu][i])
+                dl2xbar[mu,nu][i] += tmp
+      res := dl2xbar,
+  )
+  result = res.failed
+
+var fail = 0
+
+# Section A: baseline FD (smear action/force)
+fail += runGaugeActionForceFD(
+  env,
+  hypAction, hypForce,
+  actionForceCfgDefault("hypAction/hypForce")
+).failed
+fail += runGaugeActionForceFD(
+  env,
+  hypActionPrealloc, hypForcePrealloc,
+  actionForceCfgDefault("hypActionPrealloc/hypForcePrealloc")
+).failed
+fail += testSmearForceConsistency()
+
+# Section B: JVP/HVP FD
+fail += testSmearTangent()
+fail += testGaugeDerivDeriv2()
+fail += testSmearDeriv2()
+fail += testSmearDeriv2FixedChain()
+
+# Section C: smearHVP level sweep (physics coefficients)
+let levelCoefs = [
+  HypCoefs(alpha1: 0.0, alpha2: 0.0, alpha3: 0.3),
+  HypCoefs(alpha1: 0.75, alpha2: 0.0, alpha3: 0.3),
+  HypCoefs(alpha1: 0.0, alpha2: 0.6, alpha3: 0.3),
+  HypCoefs(alpha1: 0.0, alpha2: 0.6, alpha3: 0.0),
+  HypCoefs(alpha1: 0.0, alpha2: 0.0, alpha3: 0.0),
+  HypCoefs(alpha1: 0.75, alpha2: 0.0, alpha3: 0.0),
+  HypCoefs(alpha1: 0.75, alpha2: 0.6, alpha3: 0.0),
+  HypCoefs(alpha1: 0.75, alpha2: 0.6, alpha3: 0.3),
+]
+let levelLabels = [
+  "Level 3 only (α₁=α₂=0, α₃=0.3)",
+  "L1+L3 only (α₂=0)",
+  "L2+L3 only (α₁=0)",
+  "L2 only (α₁=α₃=0)",
+  "Level 0 (all α=0, identity)",
+  "Level 1 only (α₂=α₃=0)",
+  "Levels 1+2 (α₃=0)",
+  "Full HYP (α₁=0.75, α₂=0.6, α₃=0.3)",
+]
+for idx in 0..<levelCoefs.len:
+  fail += testSmearDeriv2Level(levelLabels[idx], levelCoefs[idx])
+
+# Full chain gradient
+fail += testGradForceFullChain()
+
+# Section C: adjoint identities + reverse mode
+fail += testSmearTangentAdjoint()
+fail += testSmearDerivAdjChain()
+fail += testGradForceReverseMode()
+
+# Section D: term-by-term / internal adjoints
+fail += testDgEffConversion()
+fail += testDirectContribution()
+block:
+  let res = runCoefSweep(
+    name = "smearHVPVJP coefficient sweep",
+    coefs = adjCoefCombos,
+    labels = adjCoefNames,
+    runOne = proc(c: HypCoefs): TestResult =
+      let failed = testSmearDeriv2AdjInternal(c)
+      result.name = "smearHVPVJP combo"
+      if failed == 0:
+        result.passed = 1
+      else:
+        result.failed = failed
+  )
+  fail += res.failed
+
+# Stage-specific adjoint checks
+fail += testLevel3Direct()
+fail += testLevel2Projection()
+
+if fail == 0:
+  qexFinalize()
+else:
+  qexAbort(fail)
diff --git a/tests/deriv/tprojU.nim b/tests/deriv/tprojU.nim
new file mode 100644
index 00000000..48bad860
--- /dev/null
+++ b/tests/deriv/tprojU.nim
@@ -0,0 +1,677 @@
+import math
+import random
+import maths/[matrixFunctions, types, matrixConcept, complexNumbers]
+import ./utils
+
+var gRng = initRand(123456)
+
+type
+  C64 = ComplexType[float64]
+  M = MatrixArray[3,3,C64]
+  Dir = object
+    dx: M
+    dc: M
+
+proc randUnitMat(rng: var Rand; s = 1.0): M =
+  var x = randMat[M](rng, s)
+  let nx = sqrt(x.norm2)
+  if nx != 0.0:
+    x *= (1.0 / nx)
+  x
+
+proc projectUHVPRef(res: var M; x: M; c: M; dx: M; dc: M; eps = 1e-20) =
+  discard eps
+  var z, y: M
+  projectUrsqrt(z, x, eps)
+  inverse(y, z)
+
+  var u: M
+  u := x * z
+
+  var r0: M
+  r0 := c * z
+
+  var b: M
+  b := u.adj * r0
+
+  var s: M
+  var t2: M
+  t2 := b + b.adj
+  sylsolve(s, y, t2)
+
+  var da, tmp: M
+  tmp := x.adj * dx
+  da := tmp + tmp.adj
+
+  var dy: M
+  sylsolve(dy, y, da)
+
+  var dz: M
+  tmp := dy * z
+  dz := z * tmp
+  dz := -dz
+
+  var dr0: M
+  dr0 := dc * z
+  tmp := c * dz
+  dr0 += tmp
+
+  var du: M
+  du := dx * z
+  tmp := x * dz
+  du += tmp
+
+  var db: M
+  db := du.adj * r0
+  tmp := u.adj * dr0
+  db += tmp
+
+  var q: M
+  q := dy * s
+
+  var rhs: M
+  rhs := db + db.adj
+  rhs -= q
+  rhs -= q.adj
+
+  var ds: M
+  sylsolve(ds, y, rhs)
+
+  res := dr0
+  tmp := dx * s
+  res -= tmp
+  tmp := x * ds
+  res -= tmp
+
+proc runProjHvpCase(
+    caseName: string,
+    cfg: TestConfig,
+    x, c, dx, dc, probe: M,
+    f: auto,
+    jvp: auto
+  ): TestResult =
+  echo "  ", caseName
+  runFDJVPDefault(
+    cfg = cfg,
+    makeBase = proc(sample: int): Pair[M, M] =
+      makePair(x, c),
+    makeDir = proc(sample: int; x: Pair[M, M]): Pair[M, M] =
+      makePair(dx, dc),
+    makeProbe = proc(sample: int; x: Pair[M, M]): M =
+      probe,
+    f = f,
+    jvp = jvp
+  )
+
+proc runProjHvpCaseCustom(
+    caseName: string,
+    cfg: TestConfig,
+    x, c, dx, dc, probe: M,
+    perturb: auto,
+    f: auto,
+    jvp: auto
+  ): TestResult =
+  echo "  ", caseName
+  runFDJVP(
+    cfg = cfg,
+    makeBase = proc(sample: int): Pair[M, M] =
+      makePair(x, c),
+    makeDir = proc(sample: int; x: Pair[M, M]): Pair[M, M] =
+      makePair(dx, dc),
+    makeProbe = proc(sample: int; x: Pair[M, M]): M =
+      probe,
+    perturb = perturb,
+    f = f,
+    jvp = jvp
+  )
+
+proc testProjTangent(rng: var Rand): int =
+  let cfg = initTestConfig(
+    name = "projectU JVP (tangent)",
+    samples = 10,
+    eps = 0.1,
+    atol = 1e-8,
+    rtol = 1e-6,
+    verbose = true
+  )
+  let res = runFDJVPDefault(
+    cfg = cfg,
+    makeBase = proc(sample: int): M =
+      let sx = 1.0 + 0.1 * float(sample)
+      randUnitMat(gRng, sx),
+    makeDir = proc(sample: int; x: M): M =
+      let sdx = 0.7 + 0.05 * float(sample)
+      randUnitMat(gRng, sdx),
+    makeProbe = proc(sample: int; x: M): M =
+      randMat[M](gRng, 1.0),
+    f = proc(x: M; res: var M) =
+      projectU(res, x),
+    jvp = proc(x: M; dx: M; res: var M) =
+      var u: M
+      projectU(u, x)
+      projectUJVP(res, u, x, dx)
+  )
+  result = res.failed
+
+proc testProjDeriv2FD(rng: var Rand): int =
+  echo "\n=== projectUHVP FD checks ==="
+  var fail = 0
+  let eps = 0.1
+
+  var x0 = randMat[M](gRng)
+  var dx0 = randMat[M](gRng)
+  var c0 = randMat[M](gRng)
+  var dc0 = randMat[M](gRng)
+  var a0 = randMat[M](gRng)
+  var zeroMat: M
+  zeroMat := 0
+
+  let cfgHvp = initTestConfig(
+    name = "projectUHVP FD",
+    samples = 1,
+    eps = eps,
+    atol = 1e-6,
+    rtol = 1e-5,
+    verbose = false
+  )
+  fail += runProjHvpCase(
+    "Test 0: Reference HVP",
+    cfgHvp,
+    x0, c0, dx0, dc0, a0,
+    f = proc(x: Pair[M, M]; res: var M) =
+      projectUVJP(res, x.a, x.b),
+    jvp = proc(x: Pair[M, M]; dx: Pair[M, M]; res: var M) =
+      projectUHVPRef(res, x.a, x.b, dx.a, dx.b)
+  ).failed
+
+  fail += runProjHvpCase(
+    "Test 1: Random matrices with dc",
+    cfgHvp,
+    x0, c0, dx0, dc0, a0,
+    f = proc(x: Pair[M, M]; res: var M) =
+      projectUVJP(res, x.a, x.b),
+    jvp = proc(x: Pair[M, M]; dx: Pair[M, M]; res: var M) =
+      var u: M
+      projectU(u, x.a)
+      projectUHVPu(res, u, x.a, x.b, dx.a, dx.b)
+  ).failed
+
+  fail += runProjHvpCase(
+    "Test 2: Random matrices, dc=0 (fixed chain)",
+    cfgHvp,
+    x0, c0, dx0, zeroMat, a0,
+    f = proc(x: Pair[M, M]; res: var M) =
+      projectUVJP(res, x.a, x.b),
+    jvp = proc(x: Pair[M, M]; dx: Pair[M, M]; res: var M) =
+      var u: M
+      projectU(u, x.a)
+      projectUHVPu(res, u, x.a, x.b, dx.a, dx.b)
+  ).failed
+
+  var xg = randMat[M](gRng)
+  var g: M
+  projectU(g, xg)
+  var chain = randMat[M](gRng)
+  var pDir = randTAH[M](gRng)
+  var a = randMat[M](gRng)
+  fail += runProjHvpCaseCustom(
+    "Test 3: Unitary input with multiplicative tangent",
+    cfgHvp,
+    g, chain, pDir, zeroMat, a,
+    perturb = proc(x: Pair[M, M]; dx: Pair[M, M]; eps: float; res: var Pair[M, M]) =
+      res.a := exp(eps * dx.a) * x.a
+      res.b := x.b,
+    f = proc(x: Pair[M, M]; res: var M) =
+      projectUVJP(res, x.a, x.b),
+    jvp = proc(x: Pair[M, M]; dx: Pair[M, M]; res: var M) =
+      var u: M
+      projectU(u, x.a)
+      let dxMult = dx.a * x.a
+      projectUHVPu(res, u, x.a, x.b, dxMult, zeroMat)
+  ).failed
+
+  var chainTAH = randTAH[M](gRng)
+  var pTAH = randTAH[M](gRng)
+  fail += runProjHvpCaseCustom(
+    "Test 4: Unitary input, TAH chain, multiplicative tangent",
+    cfgHvp,
+    g, chainTAH, pTAH, zeroMat, pTAH,
+    perturb = proc(x: Pair[M, M]; dx: Pair[M, M]; eps: float; res: var Pair[M, M]) =
+      res.a := exp(eps * dx.a) * x.a
+      res.b := x.b,
+    f = proc(x: Pair[M, M]; res: var M) =
+      projectUVJP(res, x.a, x.b),
+    jvp = proc(x: Pair[M, M]; dx: Pair[M, M]; res: var M) =
+      var u: M
+      projectU(u, x.a)
+      let dxMult = dx.a * x.a
+      projectUHVPu(res, u, x.a, x.b, dxMult, zeroMat)
+  ).failed
+
+  let cfgDxDc = initTestConfig(
+    name = "projectUHVP with dx and dc",
+    samples = 1,
+    eps = 0.01,
+    atol = 0.1,
+    rtol = 0.01,
+    verbose = true
+  )
+  block:
+    let x = randMat[M](gRng)
+    let c = randMat[M](gRng)
+    let dx = randMat[M](gRng)
+    let dc = randMat[M](gRng)
+    let probe = randMat[M](gRng)
+    fail += runProjHvpCase(
+      "Test 5: dx and dc",
+      cfgDxDc,
+      x, c, dx, dc, probe,
+      f = proc(x: Pair[M, M]; res: var M) =
+        projectUVJP(res, x.a, x.b),
+      jvp = proc(x: Pair[M, M]; dx: Pair[M, M]; res: var M) =
+        projectUHVP(res, x.a, x.b, dx.a, dx.b)
+    ).failed
+
+  let cfgDcOnly = initTestConfig(
+    name = "projectUHVP dc-only",
+    samples = 1,
+    eps = 0.01,
+    atol = 0.1,
+    rtol = 0.01,
+    verbose = true
+  )
+  block:
+    let x = randMat[M](gRng)
+    let c = randMat[M](gRng)
+    var dxZero: M
+    dxZero := 0
+    let dc = randMat[M](gRng)
+    let probe = randMat[M](gRng)
+    fail += runProjHvpCase(
+      "Test 6: dc-only",
+      cfgDcOnly,
+      x, c, dxZero, dc, probe,
+      f = proc(x: Pair[M, M]; res: var M) =
+        projectUVJP(res, x.a, x.b),
+      jvp = proc(x: Pair[M, M]; dx: Pair[M, M]; res: var M) =
+        projectUHVP(res, x.a, x.b, dx.a, dx.b)
+    ).failed
+
+  result = fail
+
+proc testProjDeriv2TemplateVsDirect(rng: var Rand): int =
+  echo "\n=== projectUHVP template vs direct ==="
+  var fail = 0
+  let eps = 0.1
+
+  var xg = randMat[M](gRng)
+  var g: M
+  projectU(g, xg)
+  var chainTAH = randTAH[M](gRng)
+  var pTAH = randTAH[M](gRng)
+
+  var dxMult = pTAH * g
+
+  var result1: M
+  projectUHVP(result1, g, chainTAH, dxMult)
+
+  var u_g: M
+  projectU(u_g, g)
+  var dcZero: M
+  dcZero := 0
+  var result2: M
+  projectUHVPu(result2, u_g, g, chainTAH, dxMult, dcZero)
+
+  let norm1 = result1.norm2
+  let norm2 = result2.norm2
+  let diff = (result1 - result2).norm2
+
+  echo "  |result1 (template)|^2 = ", norm1
+  echo "  |result2 (direct)|^2  = ", norm2
+  echo "  |result1 - result2|^2 = ", diff
+
+  let cfg = initTestConfig(
+    name = "projectUHVP template vs direct (FD)",
+    samples = 1,
+    eps = eps,
+    atol = 1e-6,
+    rtol = 1e-5,
+    verbose = false
+  )
+  var fd5, fde5: float
+  block:
+    let res = runFDJVP(
+      cfg = cfg,
+      makeBase = proc(sample: int): Pair[M, M] =
+        makePair(g, chainTAH),
+      makeDir = proc(sample: int; x: Pair[M, M]): Pair[M, M] =
+        var z: M
+        z := 0
+        makePair(pTAH, z),
+      makeProbe = proc(sample: int; x: Pair[M, M]): M =
+        pTAH,
+      perturb = proc(x: Pair[M, M]; dx: Pair[M, M]; eps: float; res: var Pair[M, M]) =
+        res.a := exp(eps * dx.a) * x.a
+        res.b := x.b,
+      f = proc(x: Pair[M, M]; res: var M) =
+        projectUVJP(res, x.a, x.b),
+      jvp = proc(x: Pair[M, M]; dx: Pair[M, M]; res: var M) =
+        var u: M
+        projectU(u, x.a)
+        var dc0zero: M
+        dc0zero := 0
+        let dxMult = dx.a * x.a
+        projectUHVPu(res, u, x.a, x.b, dxMult, dc0zero),
+      accept = captureFD(addr fd5, addr fde5)
+    )
+    fail += res.failed
+
+  let ana1 = redot(pTAH, result1)
+  let ana2 = redot(pTAH, result2)
+
+  var cfgCmp = cfg
+  cfgCmp.verbose = true
+  cfgCmp.atol = max(cfg.atol, cfg.fdFactor * fde5)
+  cfgCmp.rtol = 0.0
+  if not reportCompare(cfgCmp, 0, fd5, ana1, "Template vs FD"): inc fail
+  if not reportCompare(cfgCmp, 0, fd5, ana2, "Direct vs FD"): inc fail
+
+  if diff < 1e-20:
+    echo "  Template and Direct are IDENTICAL"
+  else:
+    echo "  Template and Direct DIFFER"
+    inc fail
+
+  result = fail
+
+proc testProjDeriv2Linearity(rng: var Rand): int =
+  let cfg = initTestConfig(
+    name = "projectUHVP linearity",
+    samples = 3,
+    atol = 1e-10,
+    rtol = 1e-10,
+    verbose = true
+  )
+  var x0 = randMat[M](gRng)
+  var c0 = randMat[M](gRng)
+  let res = runLinearity(
+    cfg = cfg,
+    makeVec = proc(sample: int): Dir =
+      Dir(dx: randMat[M](gRng), dc: randMat[M](gRng)),
+    makeProbe = proc(sample: int): M =
+      randMat[M](gRng),
+    combine = proc(v1, v2: Dir; a, b: float; res: var Dir) =
+      res.dx = a * v1.dx + b * v2.dx
+      res.dc = a * v1.dc + b * v2.dc,
+    apply = proc(v: Dir; res: var M) =
+      projectUHVP(res, x0, c0, v.dx, v.dc)
+  )
+  result = res.failed
+
+proc testProjAdjDx(rng: var Rand): int =
+  let cfg = initTestConfig(
+    name = "projectUHVP adjoint w.r.t dx",
+    samples = 5,
+    atol = 1e-10,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): Pair[M, M] =
+      makePair(randMat[M](gRng), randMat[M](gRng)),
+    makeDir = proc(sample: int; x: Pair[M, M]): M =
+      randMat[M](gRng),
+    jvp = proc(x: Pair[M, M]; dx: M; res: var M) =
+      var u: M
+      projectU(u, x.a)
+      var dcZero: M
+      dcZero := 0
+      projectUHVPu(res, u, x.a, x.b, dx, dcZero),
+    vjp = proc(x: Pair[M, M]; ybar: M; res: var M) =
+      var u: M
+      projectU(u, x.a)
+      projectUHVPVJP_dx(res, u, x.a, x.b, ybar)
+  )
+  result = res.failed
+
+proc testProjAdjDc(rng: var Rand): int =
+  let cfg = initTestConfig(
+    name = "projectUHVP adjoint w.r.t dc",
+    samples = 5,
+    atol = 1e-10,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): Pair[M, M] =
+      makePair(randMat[M](gRng), randMat[M](gRng)),
+    makeDir = proc(sample: int; x: Pair[M, M]): M =
+      randMat[M](gRng),
+    jvp = proc(x: Pair[M, M]; dc: M; res: var M) =
+      var u: M
+      projectU(u, x.a)
+      var dxZero: M
+      dxZero := 0
+      projectUHVPu(res, u, x.a, x.b, dxZero, dc),
+    vjp = proc(x: Pair[M, M]; ybar: M; res: var M) =
+      var u: M
+      projectU(u, x.a)
+      projectUHVPVJP_dc(res, u, x.a, x.b, ybar)
+  )
+  result = res.failed
+
+proc testProjAdjChain(rng: var Rand): int =
+  let cfg = initTestConfig(
+    name = "projectUVJP chain adjoint",
+    samples = 5,
+    atol = 1e-10,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): M =
+      randMat[M](gRng),
+    makeDir = proc(sample: int; x: M): M =
+      randMat[M](gRng),
+    jvp = proc(x: M; dx: M; res: var M) =
+      projectUVJP(res, x, dx),
+    vjp = proc(x: M; ybar: M; res: var M) =
+      projectUVJPChain(res, x, ybar)
+  )
+  result = res.failed
+
+proc testProjJVPAdjoint(rng: var Rand): int =
+  let cfg = initTestConfig(
+    name = "projectUJVP adjoint identity",
+    samples = 5,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): M =
+      randUnitMat(gRng),
+    makeDir = proc(sample: int; x: M): M =
+      randUnitMat(gRng),
+    jvp = proc(x: M; dx: M; res: var M) =
+      var u: M
+      projectU(u, x)
+      projectUJVP(res, u, x, dx),
+    vjp = proc(x: M; ybar: M; res: var M) =
+      var u: M
+      projectU(u, x)
+      projectUVJP(res, u, x, ybar)
+  )
+  result = res.failed
+
+proc testAdjointTerms(rng: var Rand): int =
+  echo "\n=== projectUHVP adjoint term checks ==="
+  var fail = 0
+
+  # Term 1: r = -dx S, S Hermitian
+  block:
+    let cfg = initTestConfig(
+      name = "Term -dx S",
+      samples = 1,
+      atol = 1e-12,
+      rtol = 1e-12,
+      verbose = false
+    )
+    let res = runAdjointIdentity(
+      cfg = cfg,
+      makeBase = proc(sample: int): M =
+        hermitianize(randMat[M](gRng)),
+      makeDir = proc(sample: int; x: M): M =
+        randMat[M](gRng),
+      jvp = proc(x: M; dx: M; res: var M) =
+        res := -dx * x,
+      vjp = proc(x: M; ybar: M; res: var M) =
+        res := -ybar * x
+    )
+    reportSummary(res)
+    fail += res.failed
+
+  # Term 2: r = Z dx† R0, Z Hermitian
+  block:
+    let cfg = initTestConfig(
+      name = "Term Z dx† R0",
+      samples = 1,
+      atol = 1e-12,
+      rtol = 1e-12,
+      verbose = false
+    )
+    let res = runAdjointIdentity(
+      cfg = cfg,
+      makeBase = proc(sample: int): Pair[M, M] =
+        makePair(hermitianize(randMat[M](gRng)), randMat[M](gRng)),
+      makeDir = proc(sample: int; x: Pair[M, M]): M =
+        randMat[M](gRng),
+      jvp = proc(x: Pair[M, M]; dx: M; res: var M) =
+        res := x.a * dx.adj * x.b,
+      vjp = proc(x: Pair[M, M]; ybar: M; res: var M) =
+        res := x.b * ybar.adj * x.a
+    )
+    reportSummary(res)
+    fail += res.failed
+
+  # Term 3: r = X† dx
+  block:
+    let cfg = initTestConfig(
+      name = "Term X† dx",
+      samples = 1,
+      atol = 1e-12,
+      rtol = 1e-12,
+      verbose = false
+    )
+    let res = runAdjointIdentity(
+      cfg = cfg,
+      makeBase = proc(sample: int): M =
+        randMat[M](gRng),
+      makeDir = proc(sample: int; x: M): M =
+        randMat[M](gRng),
+      jvp = proc(x: M; dx: M; res: var M) =
+        res := x.adj * dx,
+      vjp = proc(x: M; ybar: M; res: var M) =
+        res := x * ybar
+    )
+    reportSummary(res)
+    fail += res.failed
+
+  # Term 4: r = dx† X
+  block:
+    let cfg = initTestConfig(
+      name = "Term dx† X",
+      samples = 1,
+      atol = 1e-12,
+      rtol = 1e-12,
+      verbose = false
+    )
+    let res = runAdjointIdentity(
+      cfg = cfg,
+      makeBase = proc(sample: int): M =
+        randMat[M](gRng),
+      makeDir = proc(sample: int; x: M): M =
+        randMat[M](gRng),
+      jvp = proc(x: M; dx: M; res: var M) =
+        res := dx.adj * x,
+      vjp = proc(x: M; ybar: M; res: var M) =
+        res := x * ybar.adj
+    )
+    reportSummary(res)
+    fail += res.failed
+
+  # Term 5: r = dZ X† R0, dZ Hermitian
+  block:
+    let cfg = initTestConfig(
+      name = "Term dZ X† R0",
+      samples = 1,
+      atol = 1e-12,
+      rtol = 1e-12,
+      verbose = false
+    )
+    let res = runAdjointIdentity(
+      cfg = cfg,
+      makeBase = proc(sample: int): Pair[M, M] =
+        makePair(randMat[M](gRng), randMat[M](gRng)),
+      makeDir = proc(sample: int; x: Pair[M, M]): M =
+        hermitianize(randMat[M](gRng)),
+      jvp = proc(x: Pair[M, M]; dx: M; res: var M) =
+        res := dx * x.a.adj * x.b,
+      vjp = proc(x: Pair[M, M]; ybar: M; res: var M) =
+        res := ybar * x.b.adj * x.a
+    )
+    reportSummary(res)
+    fail += res.failed
+
+  # Term 6: Sylvester solve adjoint
+  block:
+    let cfg = initTestConfig(
+      name = "Sylvester adjoint",
+      samples = 1,
+      atol = 1e-12,
+      rtol = 1e-12,
+      verbose = false
+    )
+    let res = runAdjointIdentity(
+      cfg = cfg,
+      makeBase = proc(sample: int): M =
+        let x = randMat[M](gRng)
+        x.adj * x,
+      makeDir = proc(sample: int; x: M): M =
+        randMat[M](gRng),
+      jvp = proc(x: M; dx: M; res: var M) =
+        sylsolve(res, x, dx),
+      vjp = proc(x: M; ybar: M; res: var M) =
+        sylsolve(res, x, ybar)
+    )
+    reportSummary(res)
+    fail += res.failed
+
+  result = fail
+
+var fail = 0
+
+# Section A: JVP/HVP FD
+fail += testProjTangent(gRng)
+fail += testProjDeriv2FD(gRng)
+fail += testProjDeriv2TemplateVsDirect(gRng)
+fail += testProjDeriv2Linearity(gRng)
+
+# Section B: adjoint identities
+fail += testProjAdjDx(gRng)
+fail += testProjAdjDc(gRng)
+fail += testProjAdjChain(gRng)
+fail += testProjJVPAdjoint(gRng)
+
+# Section C: term-by-term adjoint checks
+fail += testAdjointTerms(gRng)
+
+if fail == 0:
+  echo "\nAll tests passed"
+else:
+  echo "\n", fail, " tests failed"
+  quit(fail)
diff --git a/tests/base/tstoutderiv.nim b/tests/deriv/tstout.nim
similarity index 52%
rename from tests/base/tstoutderiv.nim
rename to tests/deriv/tstout.nim
index 5c9ee6a9..d1a0420a 100644
--- a/tests/base/tstoutderiv.nim
+++ b/tests/deriv/tstout.nim
@@ -1,91 +1,21 @@
-import qex, physics/qcdTypes, algorithms/numdiff, gauge/stoutsmear
-import os, sequtils
-
-proc printPlaq(g: auto) =
-  let
-    p = g.plaq
-    sp = 2.0*(p[0]+p[1]+p[2])
-    tp = 2.0*(p[3]+p[4]+p[5])
-  echo "plaq ",p
-  echo "plaq ss: ",sp," st: ",tp," tot: ",p.sum
+import qex, physics/qcdTypes, gauge/stoutsmear
+import ./utils
 
 qexInit()
 
-let
-  fn = if paramCount() > 0: paramStr 1 else: ""
-  lat = if fn.len == 0: @[8,8,8,8] else: fn.getFileLattice
-  lo = lat.newLayout
-var g = lo.newGauge
+var env = initGaugeTestEnv()
+let lo = env.lo
+var g = env.g
+
+type
+  GaugeField = typeof(g)
+
 var ss = lo.newStoutSmear(0.1)
-if fn.len == 0:
-  g.random
-  for n in 0..<10:
-    ss.smear(g, g)
-elif 0 != g.loadGauge fn:
-  echo "ERROR: couldn't load gauge file: ",fn
-  qexFinalize()
-  quit(-1)
-g.printPlaq
 
 let gc = GaugeActionCoeffs(plaq:6.0)
 echo "S(g): ",gc.gaugeAction1(g)
 
-var r = lo.newRNGField(MRG32k3a, 4321)
-
-# SU(3) derivative convention, with Tr(T_a T_b) = -1/2
-# F'(U) = -2 T_a F'_a(U) = -2 T_a d/dw_a F(exp(w_b T_b) U) |_{w_a=0}
-# Tr(F'(U) T_a) = d/dw_a F(exp(w_b T_b) U) |_{w_a=0}
-
-proc addnoise[G](x:float, p:G, g:G, ng:G) =
-  qexGC()
-  threads:
-    for mu in 0..<g.len:
-      for e in g[mu]:
-        let t = x*p[mu][e]
-        ng[mu][e] := exp(t)*g[mu][e]
-  qexGC()
-
-# Test by computing the derivative of F(exp(t*p)g), dF/dt at t=0
-# d/dt F(exp(t*p)g) |_{t=0} = d/dt F(exp(t*p_b T_b)g) |_{t=0}
-#   = p_a d/d(t*p_a) F(exp(t*p_b T_b)g) |_{t=0}
-#   = p_a Tr(T_a F'(g))
-#   = Tr(p F'(g))
-template test(action:untyped, deriv:untyped):auto =
-  proc testImpl():auto {.gensym.} =
-    tic("test")
-    var fail = 0
-    echo "### Testing ",astToStr(action)," ",astToStr(deriv)
-    let gg = lo.newGauge
-    let f = lo.newGauge
-    let p = lo.newGauge
-    deriv(g, f)
-    for n in 0..<5:
-      p.randomTAH r
-      var d,e:float
-      proc testAct(x:float):float =
-        tic("testAct")
-        qexGC()
-        addnoise(x, p, g, gg)
-        result = action(gg)
-        qexGC()
-        toc("done")
-      ndiff(d, e, testAct, 0, 1.0)
-      var pf = 0.0
-      for mu in 0..<p.len:
-        pf += redot(p[mu], f[mu])
-      let err = abs(pf-d)
-      let etol = max(2e-8,32*e)
-      if err<etol and err<1e-5 and abs(err/pf)<1e-7:
-        echo "Test ",n,"  Passed:  p.f: ",pf," \tndiff: ",d," \tdelta: ",pf-d," \terr(ndiff): ",e
-      else:
-        echo "Test ",n,"  Failed:  p.f: ",pf," \tndiff: ",d," \tdelta: ",pf-d," \terr(ndiff): ",e
-        inc fail
-    toc("done")
-    fail
-  qexGC()
-  testImpl()
-
-var fail = test(gc.gaugeAction1, gc.gaugeForce)
+var fail = 0
 
 proc smearTest0[G](ss:var StoutSmear, gf:G, fl:G) =
   const nc = gf[0][0].nrows.float
@@ -128,7 +58,6 @@ proc smearedForceTest0(g:auto, f:auto) =
   ss.smearTest0Deriv(f, ds)
   contractProjectTAH(g, f)
 
-fail += test(smearedActionTest0, smearedForceTest0)
 
 proc smearedAction(g:auto):auto =
   var sg = lo.newGauge
@@ -142,7 +71,6 @@ proc smearedForce(g:auto, f:auto) =
   ss.smearDeriv(f, ds)
   contractProjectTAH(g, f)
 
-fail += test(smearedAction, smearedForce)
 
 var s2 = lo.newStoutSmear(0.09)
 
@@ -164,7 +92,6 @@ proc smeared2Force(g:auto, f:auto) =
   ss.smearDeriv(f, f2)
   contractProjectTAH(g, f)
 
-fail += test(smeared2Action, smeared2Force)
 
 var s3 = lo.newStoutSmear(0.12)
 
@@ -192,7 +119,24 @@ proc smeared3Force(g:auto, f:auto) =
   ss.smearDeriv(f, f2)
   contractProjectTAH(g, f)
 
-fail += test(smeared3Action, smeared3Force)
+type
+  ActionProc = proc(g: GaugeField): float
+  ForceProc = proc(g: GaugeField; f: GaugeField)
+
+let pipelines: seq[(string, ActionProc, ForceProc)] = @[
+  ("smearedActionTest0/smearedForceTest0", smearedActionTest0, smearedForceTest0),
+  ("smearedAction/smearedForce", smearedAction, smearedForce),
+  ("smeared2Action/smeared2Force", smeared2Action, smeared2Force),
+  ("smeared3Action/smeared3Force", smeared3Action, smeared3Force),
+]
+
+# Section A: baseline FD
+for (name, action, force) in pipelines:
+  fail += runGaugeActionForceFD(
+    env,
+    action, force,
+    actionForceCfgDefault(name)
+  ).failed
 
 # echoTimers()
 
diff --git a/tests/deriv/tsymstaple.nim b/tests/deriv/tsymstaple.nim
new file mode 100644
index 00000000..7eeae0b1
--- /dev/null
+++ b/tests/deriv/tsymstaple.nim
@@ -0,0 +1,1574 @@
+import qex, physics/qcdTypes, gauge/smearutil, algorithms/numdiff
+import maths/matrixFunctions
+import ./utils
+
+qexInit()
+
+var env = initGaugeTestEnv(preSmear = false)
+let lo = env.lo
+var g = env.g
+var r = env.r
+
+proc setupSymStaple(mu, nu: int; rng: var auto): auto =
+  var g0 = lo.newGauge
+  g0.random
+  let g1 = g0[nu]
+  let g2 = g0[mu]
+  var c = g1.newOneOf
+  c.randomTAH rng
+  let s1 = newShifter(g1, mu, 1)
+  let s2 = newShifter(g2, nu, 1)
+  let s  = newShifter(c, nu, 1)
+  let sm1 = newShifter(g1, nu, -1)
+  let sm2 = newShifter(g2, mu, -1)
+  var tm1 = g1.newOneOf
+  var tm2 = g1.newOneOf
+  (g1: g1, g2: g2, c: c, s1: s1, s2: s2, s: s, sm1: sm1, sm2: sm2, tm1: tm1, tm2: tm2)
+
+type H3[T] = Pair[T, Pair[T, T]]
+
+template makeH3(a, b, c: untyped): untyped =
+  makePair(a, makePair(b, c))
+
+template h2(x: untyped): untyped = x.b.a
+template h3(x: untyped): untyped = x.b.b
+
+proc scopedCfg(name: string; base: TestConfig): TestConfig =
+  initTestConfig(
+    name = name,
+    samples = base.samples,
+    atol = base.atol,
+    rtol = base.rtol,
+    verbose = base.verbose
+  )
+
+proc testSymStapleJvpFD(): int =
+  echo "\n=== symStapleJVP isolated test (multiplicative) ==="
+  let mu = 0
+  let nu = 1
+  let alp = 0.5
+  var g1 = lo.newGauge
+  var g2 = lo.newGauge
+  g1.random
+  g2.random
+  type Fld = type(g1[0])
+  proc makeBase(sample: int): Pair[type(g1), type(g2)] =
+    makePair(g1, g2)
+  proc makeDir(sample: int; x: Pair[type(g1), type(g2)]): Pair[type(g1), type(g2)] =
+    var d1 = lo.newGauge
+    var d2 = lo.newGauge
+    threads:
+      for d in 0..<4:
+        d1[d] := 0
+        d2[d] := 0
+    d1[mu].randomTAH env.r
+    d2[nu].randomTAH env.r
+    makePair(d1, d2)
+  proc makeProbe(sample: int; x: Pair[type(g1), type(g2)]): Fld =
+    var p: Fld
+    p.new(lo)
+    p.gaussian env.r
+    p
+  proc f(x: Pair[type(g1), type(g2)]; res: var Fld) =
+    var s1 = newShifter(x.a[mu], nu, 1)
+    var s2 = newShifter(x.b[nu], mu, 1)
+    var sm = newShifter(x.a[mu], mu, -1)
+    var tm: Fld
+    tm.new(lo)
+    let resPtr = cast[ptr Fld](unsafeAddr(res))
+    threads:
+      discard s1 ^*! x.a[mu]
+      discard s2 ^*! x.b[nu]
+      resPtr[] := 0
+      symStaple(resPtr[], alp, x.a[mu], x.b[nu], s1, s2, tm, sm)
+  proc jvp(x: Pair[type(g1), type(g2)]; dx: Pair[type(g1), type(g2)]; res: var Fld) =
+    var s1 = newShifter(x.a[mu], nu, 1)
+    var s2 = newShifter(x.b[nu], mu, 1)
+    var sm = newShifter(x.a[mu], mu, -1)
+    var tm: Fld
+    tm.new(lo)
+    var dg1mu: Fld
+    var dg2nu: Fld
+    dg1mu.new(lo)
+    dg2nu.new(lo)
+    threads:
+      dg1mu := dx.a[mu] * x.a[mu]
+      dg2nu := dx.b[nu] * x.b[nu]
+    var ds1 = newShifter(dg1mu, nu, 1)
+    var ds2 = newShifter(dg2nu, mu, 1)
+    let resPtr = cast[ptr Fld](unsafeAddr(res))
+    threads:
+      discard s1 ^*! x.a[mu]
+      discard s2 ^*! x.b[nu]
+      discard ds1 ^*! dg1mu
+      discard ds2 ^*! dg2nu
+      resPtr[] := 0
+      symStapleJVP(resPtr[], alp, x.a[mu], x.b[nu], s1, s2, dg1mu, dg2nu, ds1, ds2, tm, sm)
+  let cfg = initTestConfig(
+    name = "symStapleJVP isolated test (multiplicative)",
+    samples = 1,
+    eps = 0.01,
+    scale = 2.0,
+    atol = 0.1,
+    rtol = 0.01,
+    fdFactor = 3.0,
+    verbose = true
+  )
+  let res = runFDJVPDefault(
+    cfg = cfg,
+    makeBase = makeBase,
+    makeDir = makeDir,
+    makeProbe = makeProbe,
+    f = f,
+    jvp = jvp
+  )
+  result = res.failed
+
+proc testSymStapleHvpFD(): int =
+  echo "\n=== symStapleHVP isolated test (multiplicative) ==="
+  let mu = 0
+  let nu = 1
+  var g1 = lo.newGauge
+  var g2 = lo.newGauge
+  g1.random
+  g2.random
+  var c = lo.newGauge
+  c.randomTAH env.r
+  type Fld = type(g1[0])
+  type X = Pair[type(g1), Pair[type(g2), type(c)]]
+  type Y = Pair[Fld, Fld]
+  proc makeBase(sample: int): X =
+    makePair(g1, makePair(g2, c))
+  proc makeDir(sample: int; x: X): X =
+    var d1 = lo.newGauge
+    var d2 = lo.newGauge
+    var dc = lo.newGauge
+    for d in 0..<4:
+      d1[d] := 0
+      d2[d] := 0
+      dc[d] := 0
+    d1[mu].randomTAH env.r
+    d2[nu].randomTAH env.r
+    dc[mu].randomTAH env.r
+    makePair(d1, makePair(d2, dc))
+  proc makeProbe(sample: int; x: X): Y =
+    var p1, p2: Fld
+    p1.new(lo)
+    p2.new(lo)
+    p1.gaussian env.r
+    p2.gaussian env.r
+    makePair(p1, p2)
+  proc perturb(x: X; dx: X; eps: float; res: var X) =
+    addNoiseExp(eps, dx.a, x.a, res.a)
+    addNoiseExp(eps, dx.b.a, x.b.a, res.b.a)
+    for d in 0..<4:
+      res.b.b[d] := x.b.b[d]
+    res.b.b[mu] := x.b.b[mu] + eps * dx.b.b[mu]
+  proc grad(x: X; res: var Y) =
+    var s1 = newShifter(x.a[mu], nu, 1)
+    var s2 = newShifter(x.b.a[nu], mu, 1)
+    var sc = newShifter(x.b.b[mu], mu, 1)
+    var sm1 = newShifter(x.a[mu], mu, -1)
+    var sm2 = newShifter(x.a[mu], nu, -1)
+    var tm1, tm2: Fld
+    tm1.new(lo)
+    tm2.new(lo)
+    let resPtr = cast[ptr Y](unsafeAddr(res))
+    threads:
+      discard s1 ^*! x.a[mu]
+      discard s2 ^*! x.b.a[nu]
+      discard sc ^*! x.b.b[mu]
+      resPtr[].a := 0
+      resPtr[].b := 0
+      symStapleVJP(resPtr[].a, resPtr[].b, x.a[mu], x.b.a[nu], s1, s2, x.b.b[mu], sc, tm1, tm2, sm1, sm2)
+  proc hvp(x: X; dx: X; res: var Y) =
+    var dg1mu: Fld
+    var dg2nu: Fld
+    dg1mu.new(lo)
+    dg2nu.new(lo)
+    threads:
+      dg1mu := dx.a[mu] * x.a[mu]
+      dg2nu := dx.b.a[nu] * x.b.a[nu]
+    var s1 = newShifter(x.a[mu], nu, 1)
+    var s2 = newShifter(x.b.a[nu], mu, 1)
+    var sc = newShifter(x.b.b[mu], mu, 1)
+    var sm1 = newShifter(x.a[mu], mu, -1)
+    var sm2 = newShifter(x.a[mu], nu, -1)
+    var tm1, tm2: Fld
+    tm1.new(lo)
+    tm2.new(lo)
+    var ds1 = newShifter(dg1mu, nu, 1)
+    var ds2 = newShifter(dg2nu, mu, 1)
+    var dsc = newShifter(dx.b.b[mu], mu, 1)
+    var acc1, acc2: Fld
+    acc1.new(lo)
+    acc2.new(lo)
+    let resPtr = cast[ptr Y](unsafeAddr(res))
+    threads:
+      discard s1 ^*! x.a[mu]
+      discard s2 ^*! x.b.a[nu]
+      discard sc ^*! x.b.b[mu]
+      discard ds1 ^*! dg1mu
+      discard ds2 ^*! dg2nu
+      discard dsc ^*! dx.b.b[mu]
+      resPtr[].a := 0
+      resPtr[].b := 0
+      symStapleHVP(resPtr[].a, resPtr[].b, acc1, acc2, x.a[mu], x.b.a[nu], s1, s2, x.b.b[mu], sc,
+                   dg1mu, dg2nu, dx.b.b[mu], ds1, ds2, dsc, tm1, tm2, sm1, sm2)
+  let cfg = initTestConfig(
+    name = "symStapleHVP isolated test (multiplicative)",
+    samples = 1,
+    eps = 0.01,
+    scale = 2.0,
+    atol = 1e-2,
+    rtol = 1e-3,
+    fdFactor = 3.0,
+    verbose = true
+  )
+  let res = runFDJVP(
+    cfg = cfg,
+    makeBase = makeBase,
+    makeDir = makeDir,
+    makeProbe = makeProbe,
+    perturb = perturb,
+    f = grad,
+    jvp = hvp
+  )
+  result = res.failed
+
+proc testSymStapleDeriv2Full(): int =
+  var rng = lo.newRNGField(MRG32k3a, 1234)
+  # Pick a fixed direction (μ,ν) to define g1,g2 and the corresponding shifters.
+  let mu = 1
+  let nu = 2
+  let setup = setupSymStaple(mu, nu, rng)
+  let g1 = setup.g1
+  let g2 = setup.g2
+  let c = setup.c
+  let s1 = setup.s1
+  let s2 = setup.s2
+  let s = setup.s
+  let sm1 = setup.sm1
+  let sm2 = setup.sm2
+  let tm1 = setup.tm1
+  let tm2 = setup.tm2
+  type
+    Fld = type(g1)
+    X = Pair[Fld, Pair[Fld, Fld]]
+    Y = Pair[Fld, Fld]
+  let cfg = initTestConfig(
+    name = "tsymstaple2(link)",
+    samples = 5,
+    eps = 1e-3,
+    scale = 2.0,
+    atol = 1e-8,
+    rtol = 1e-6,
+    fdFactor = 5.0,
+    verbose = true
+  )
+  let res = runFDJVP(
+    cfg = cfg,
+    makeBase = proc(sample: int): X =
+      makePair(g1, makePair(g2, c)),
+    makeDir = proc(sample: int; x: X): X =
+      var dg1 = g1.newOneOf
+      var dg2 = g2.newOneOf
+      var dc = c.newOneOf
+      dg1.randomTAH rng
+      dg2.randomTAH rng
+      dc.randomTAH rng
+      makePair(dg1, makePair(dg2, dc)),
+    makeProbe = proc(sample: int; x: X): Y =
+      var probe1 = g1.newOneOf
+      var probe2 = g2.newOneOf
+      probe1.randomTAH rng
+      probe2.randomTAH rng
+      makePair(probe1, probe2),
+    perturb = proc(x: X; dx: X; eps: float; res: var X) =
+      addNoiseExpField(eps, dx.a, x.a, res.a)
+      addNoiseExpField(eps, dx.b.a, x.b.a, res.b.a)
+      res.b.b := x.b.b
+      res.b.b += eps * dx.b.b,
+    f = proc(x: X; res: var Y) =
+      discard s1 ^*! x.a
+      discard s2 ^*! x.b.a
+      discard s  ^*! x.b.b
+      res.a := 0
+      res.b := 0
+      symStapleVJP(res.a, res.b, x.a, x.b.a, s1, s2, x.b.b, s, tm1, tm2, sm1, sm2),
+    jvp = proc(x: X; dx: X; res: var Y) =
+      var dg1Eff = g1.newOneOf
+      var dg2Eff = g2.newOneOf
+      dg1Eff := dx.a * x.a
+      dg2Eff := dx.b.a * x.b.a
+      var ds1 = newShifter(dg1Eff, mu, 1)
+      var ds2 = newShifter(dg2Eff, nu, 1)
+      var dsc = newShifter(dx.b.b, nu, 1)
+      discard s1 ^*! x.a
+      discard s2 ^*! x.b.a
+      discard s  ^*! x.b.b
+      discard ds1 ^*! dg1Eff
+      discard ds2 ^*! dg2Eff
+      discard dsc ^*! dx.b.b
+      var acc1 = g1.newOneOf
+      var acc2 = g2.newOneOf
+      res.a := 0
+      res.b := 0
+      symStapleHVP(res.a, res.b, acc1, acc2, x.a, x.b.a, s1, s2, x.b.b, s,
+                   dg1Eff, dg2Eff, dx.b.b, ds1, ds2, dsc, tm1, tm2, sm1, sm2)
+  )
+  result = res.failed
+
+proc testIsolatedG1(): int =
+  ## Test with only dg1 non-zero (dg2=0, dc=0)
+  ## This isolates the contribution from varying g1 and its shift s1.
+  let mu = 1
+  let nu = 2
+  var rng = lo.newRNGField(MRG32k3a, 5555)
+  let rptr = addr rng
+  let setup = setupSymStaple(mu, nu, rng)
+  type
+    Fld = type(setup.g1)
+    X = H3[Fld]
+    Y = Pair[Fld, Fld]
+  let g1 = setup.g1
+  let g2 = setup.g2
+  let c = setup.c
+  let s1 = setup.s1
+  let s2 = setup.s2
+  let s = setup.s
+  let sm1 = setup.sm1
+  let sm2 = setup.sm2
+  let tm1 = setup.tm1
+  let tm2 = setup.tm2
+
+  var zero2 = g2.newOneOf
+  var zeroc = c.newOneOf
+  zero2 := 0
+  zeroc := 0
+  var ds2_zero = newShifter(zero2, nu, 1)
+  var dsc_zero = newShifter(zeroc, nu, 1)
+
+  let cfg = initTestConfig(
+    name = "testIsolatedG1",
+    samples = 3,
+    atol = 1e-8,
+    rtol = 0.1,
+    verbose = true
+  )
+  let res = runFDJVPDefault(
+    cfg = cfg,
+    makeBase = proc(sample: int): X =
+      makeH3(g1, g2, c),
+    makeDir = proc(sample: int; x: X): X =
+      var dg1 = g1.newOneOf
+      dg1.randomTAH rptr[]
+      makeH3(dg1, zero2, zeroc),
+    makeProbe = proc(sample: int; x: X): Y =
+      var probe1 = g1.newOneOf
+      var probe2 = g2.newOneOf
+      probe1.randomTAH rptr[]
+      probe2.randomTAH rptr[]
+      makePair(probe1, probe2),
+    f = proc(x: X; res: var Y) =
+      discard s1 ^*! x.a
+      discard s2 ^*! h2(x)
+      discard s  ^*! h3(x)
+      res.a := 0
+      res.b := 0
+      symStapleVJP(res.a, res.b, x.a, h2(x), s1, s2, h3(x), s, tm1, tm2, sm1, sm2),
+    jvp = proc(x: X; dx: X; res: var Y) =
+      var dg1Eff = x.a.newOneOf
+      dg1Eff := dx.a * x.a
+      var ds1 = newShifter(dg1Eff, mu, 1)
+      discard s1 ^*! x.a
+      discard s2 ^*! h2(x)
+      discard s  ^*! h3(x)
+      discard ds1 ^*! dg1Eff
+      discard ds2_zero ^*! zero2
+      discard dsc_zero ^*! zeroc
+      res.a := 0
+      res.b := 0
+      var acc1 = res.a.newOneOf
+      var acc2 = res.b.newOneOf
+      symStapleHVP(res.a, res.b, acc1, acc2, x.a, h2(x), s1, s2, h3(x), s,
+                   dg1Eff, zero2, zeroc, ds1, ds2_zero, dsc_zero, tm1, tm2, sm1, sm2)
+  )
+  result = res.failed
+
+proc testIsolatedG2(): int =
+  ## Test with only dg2 non-zero (dg1=0, dc=0)
+  ## This isolates the contribution from varying g2 and its shift s2.
+  let mu = 1
+  let nu = 2
+  var rng = lo.newRNGField(MRG32k3a, 6666)
+  let rptr = addr rng
+  let setup = setupSymStaple(mu, nu, rng)
+  type
+    Fld = type(setup.g1)
+    X = H3[Fld]
+    Y = Pair[Fld, Fld]
+  let g1 = setup.g1
+  let g2 = setup.g2
+  let c = setup.c
+  let s1 = setup.s1
+  let s2 = setup.s2
+  let s = setup.s
+  let sm1 = setup.sm1
+  let sm2 = setup.sm2
+  let tm1 = setup.tm1
+  let tm2 = setup.tm2
+
+  var zero1 = g1.newOneOf
+  var zeroc = c.newOneOf
+  zero1 := 0
+  zeroc := 0
+  var ds1_zero = newShifter(zero1, mu, 1)
+  var dsc_zero = newShifter(zeroc, nu, 1)
+
+  let cfg = initTestConfig(
+    name = "testIsolatedG2",
+    samples = 3,
+    atol = 1e-8,
+    rtol = 0.1,
+    verbose = true
+  )
+  let res = runFDJVPDefault(
+    cfg = cfg,
+    makeBase = proc(sample: int): X =
+      makeH3(g1, g2, c),
+    makeDir = proc(sample: int; x: X): X =
+      var dg2 = g2.newOneOf
+      dg2.randomTAH rptr[]
+      makeH3(zero1, dg2, zeroc),
+    makeProbe = proc(sample: int; x: X): Y =
+      var probe1 = g1.newOneOf
+      var probe2 = g2.newOneOf
+      probe1.randomTAH rptr[]
+      probe2.randomTAH rptr[]
+      makePair(probe1, probe2),
+    f = proc(x: X; res: var Y) =
+      discard s1 ^*! x.a
+      discard s2 ^*! h2(x)
+      discard s  ^*! h3(x)
+      res.a := 0
+      res.b := 0
+      symStapleVJP(res.a, res.b, x.a, h2(x), s1, s2, h3(x), s, tm1, tm2, sm1, sm2),
+    jvp = proc(x: X; dx: X; res: var Y) =
+      var dg2Eff = h2(x).newOneOf
+      dg2Eff := h2(dx) * h2(x)
+      var ds2 = newShifter(dg2Eff, nu, 1)
+      discard s1 ^*! x.a
+      discard s2 ^*! h2(x)
+      discard s  ^*! h3(x)
+      discard ds1_zero ^*! zero1
+      discard ds2 ^*! dg2Eff
+      discard dsc_zero ^*! zeroc
+      res.a := 0
+      res.b := 0
+      var acc1 = res.a.newOneOf
+      var acc2 = res.b.newOneOf
+      symStapleHVP(res.a, res.b, acc1, acc2, x.a, h2(x), s1, s2, h3(x), s,
+                   zero1, dg2Eff, zeroc, ds1_zero, ds2, dsc_zero, tm1, tm2, sm1, sm2)
+  )
+  result = res.failed
+
+proc testIsolatedC(): int =
+  ## Test with only dc non-zero (dg1=0, dg2=0)
+  ## This isolates the contribution from varying c and its shift s.
+  let mu = 1
+  let nu = 2
+  var rng = lo.newRNGField(MRG32k3a, 7777)
+  let rptr = addr rng
+  let setup = setupSymStaple(mu, nu, rng)
+  type
+    Fld = type(setup.g1)
+    X = H3[Fld]
+    Y = Pair[Fld, Fld]
+  let g1 = setup.g1
+  let g2 = setup.g2
+  let c = setup.c
+  let s1 = setup.s1
+  let s2 = setup.s2
+  let s = setup.s
+  let sm1 = setup.sm1
+  let sm2 = setup.sm2
+  let tm1 = setup.tm1
+  let tm2 = setup.tm2
+
+  var zero1 = g1.newOneOf
+  var zero2 = g2.newOneOf
+  zero1 := 0
+  zero2 := 0
+  var ds1_zero = newShifter(zero1, mu, 1)
+  var ds2_zero = newShifter(zero2, nu, 1)
+
+  let cfg = initTestConfig(
+    name = "testIsolatedC",
+    samples = 3,
+    atol = 1e-8,
+    rtol = 0.1,
+    verbose = true
+  )
+  let res = runFDJVP(
+    cfg = cfg,
+    makeBase = proc(sample: int): X =
+      makeH3(g1, g2, c),
+    makeDir = proc(sample: int; x: X): X =
+      var dc = c.newOneOf
+      dc.randomTAH rptr[]
+      makeH3(zero1, zero2, dc),
+    makeProbe = proc(sample: int; x: X): Y =
+      var probe1 = g1.newOneOf
+      var probe2 = g2.newOneOf
+      probe1.randomTAH rptr[]
+      probe2.randomTAH rptr[]
+      makePair(probe1, probe2),
+    perturb = proc(x: X; dx: X; eps: float; res: var X) =
+      addNoiseExpField(eps, dx.a, x.a, res.a)
+      addNoiseExpField(eps, h2(dx), h2(x), res.b.a)
+      res.b.b := h3(x)
+      res.b.b += eps * h3(dx),
+    f = proc(x: X; res: var Y) =
+      discard s1 ^*! x.a
+      discard s2 ^*! h2(x)
+      discard s  ^*! h3(x)
+      res.a := 0
+      res.b := 0
+      symStapleVJP(res.a, res.b, x.a, h2(x), s1, s2, h3(x), s, tm1, tm2, sm1, sm2),
+    jvp = proc(x: X; dx: X; res: var Y) =
+      var dsc = newShifter(h3(dx), nu, 1)
+      discard s1 ^*! x.a
+      discard s2 ^*! h2(x)
+      discard s  ^*! h3(x)
+      discard ds1_zero ^*! zero1
+      discard ds2_zero ^*! zero2
+      discard dsc ^*! h3(dx)
+      res.a := 0
+      res.b := 0
+      var acc1 = res.a.newOneOf
+      var acc2 = res.b.newOneOf
+      symStapleHVP(res.a, res.b, acc1, acc2, x.a, h2(x), s1, s2, h3(x), s,
+                   zero1, zero2, h3(dx), ds1_zero, ds2_zero, dsc, tm1, tm2, sm1, sm2)
+  )
+  result = res.failed
+
+proc testSymStapleDeriv(): int =
+  ## Verify symStapleVJP is correct by comparing with FD of symStaple.
+  ## This tests the first derivative, not the second.
+  let mu = 1
+  let nu = 2
+  var rng = lo.newRNGField(MRG32k3a, 9999)
+  let rptr = addr rng
+  let setup = setupSymStaple(mu, nu, rng)
+  type
+    Fld = type(setup.g1)
+    X = Pair[Fld, Fld]
+  let g1 = setup.g1
+  let g2 = setup.g2
+  let c = setup.c
+  let s1 = setup.s1
+  let s2 = setup.s2
+  let s = setup.s
+  let sm1 = setup.sm1
+  let sm2 = setup.sm2
+  let tm1 = setup.tm1
+  let sm = sm1
+
+  let alp = 1.0
+  let cfg = initTestConfig(
+    name = "testSymStapleDeriv(g1)",
+    samples = 3,
+    atol = 1e-8,
+    rtol = 0.1,
+    verbose = true
+  )
+
+  let res = runFDScalarJVPDefault(
+    cfg = cfg,
+    makeBase = proc(sample: int): X =
+      makePair(g1, g2),
+    makeDir = proc(sample: int; x: X): X =
+      var dg1 = g1.newOneOf
+      dg1.randomTAH rptr[]
+      var zero2 = g2.newOneOf
+      zero2 := 0
+      makePair(dg1, zero2),
+    f = proc(x: X): float =
+      var staple = g1.newOneOf
+      staple := 0
+      discard s1 ^*! x.a
+      discard s2 ^*! x.b
+      symStaple(staple, alp, x.a, x.b, s1, s2, tm1, sm)
+      redot(c, staple),
+    jvp = proc(x: X; dx: X): float =
+      var dg1Eff = x.a.newOneOf
+      dg1Eff := dx.a * x.a
+      var f1 = g1.newOneOf
+      var f2 = g2.newOneOf
+      f1 := 0
+      f2 := 0
+      discard s1 ^*! x.a
+      discard s2 ^*! x.b
+      discard s  ^*! c
+      symStapleVJP(f1, f2, x.a, x.b, s1, s2, c, s, tm1, tm1, sm1, sm2)
+      redot(dg1Eff, f1)
+  )
+  result = res.failed
+
+proc testSymStapleDerivAdjChain(): int =
+  let cfg = initTestConfig(
+    name = "symStapleVJPChain adjoint identity",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let mu = 0
+  let nu = 1
+
+  type Fld = type(g[0])
+
+  var s1_nu_mu = newShifter(g[nu], mu, 1)
+  var s1_mu_nu = newShifter(g[mu], nu, 1)
+  var shiftedF2bar = newShifter(g[nu], nu, 1)
+  var shiftedF1bar = newShifter(g[mu], mu, 1)
+  var sm1_nu = newShifter(g[nu], nu, -1)
+  var sm1_mu = newShifter(g[mu], mu, -1)
+
+  var tm1, tm2: Fld
+  tm1.new(lo)
+  tm2.new(lo)
+
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): int =
+      0,
+    makeDir = proc(sample: int; x: int): Fld =
+      var c: Fld
+      c.new(lo)
+      threads:
+        c.gaussian r
+      c,
+    jvp = proc(x: int; dx: Fld; res: var Pair[Fld, Fld]) =
+      var sc = newShifter(dx, nu, 1)
+      let resPtr = cast[ptr Pair[Fld, Fld]](unsafeAddr(res))
+      threads:
+        discard s1_nu_mu ^*! g[nu]
+        discard s1_mu_nu ^*! g[mu]
+        discard sc ^*! dx
+        resPtr[].a := 0
+        resPtr[].b := 0
+        symStapleVJP(resPtr[].a, resPtr[].b, g[nu], g[mu], s1_nu_mu, s1_mu_nu, dx, sc, tm1, tm2, sm1_nu, sm1_mu),
+    vjp = proc(x: int; ybar: Pair[Fld, Fld]; res: var Fld) =
+      let resPtr = cast[ptr Fld](unsafeAddr(res))
+      threads:
+        discard s1_nu_mu ^*! g[nu]
+        discard s1_mu_nu ^*! g[mu]
+        resPtr[] := 0
+        symStapleVJPChain(resPtr[], g[nu], g[mu], s1_nu_mu, s1_mu_nu,
+                          ybar.a, ybar.b, shiftedF2bar, shiftedF1bar, tm1, tm2, sm1_nu),
+  )
+  result = res.failed
+
+## Test each term of symStapleVJP individually
+proc testSymStapleDerivTermByTerm(): int =
+  echo "\n### Testing symStapleVJP terms individually ###"
+  var fail = 0
+  let cfgBase = initTestConfig(
+    name = "symStapleVJP term",
+    samples = 1,
+    atol = 1e-10,
+    rtol = 1e-10,
+    verbose = true
+  )
+
+  let mu = 0
+  let nu = 1
+
+  type Fld = type(g[0])
+
+  # Random inputs
+  var c: Fld
+  c.new(lo)
+  threads:
+    c.gaussian r
+  proc makeBase(sample: int): int = 0
+  proc makeDir(sample: int; x: int): Fld = c
+
+  echo "\n  Testing Term 1: f1[x] += c[x] s1g[x] s2g[x]†"
+  block:
+    let res = runAdjointIdentity(
+      cfg = cfgBase,
+      makeBase = makeBase,
+      makeDir = makeDir,
+      jvp = proc(x: int; dx: Fld; res: var Fld) =
+        var s1_nu_mu = newShifter(g[nu], mu, 1)
+        var s1_mu_nu = newShifter(g[mu], nu, 1)
+        var s1g, s2g: Fld
+        s1g.new(lo)
+        s2g.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_nu_mu ^*! g[nu]
+          discard s1_mu_nu ^*! g[mu]
+          s1g := s1_nu_mu.field
+          s2g := s1_mu_nu.field
+          resPtr[] := dx * s1g * s2g.adj,
+      vjp = proc(x: int; ybar: Fld; res: var Fld) =
+        var s1_nu_mu = newShifter(g[nu], mu, 1)
+        var s1_mu_nu = newShifter(g[mu], nu, 1)
+        var s1g, s2g: Fld
+        s1g.new(lo)
+        s2g.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_nu_mu ^*! g[nu]
+          discard s1_mu_nu ^*! g[mu]
+          s1g := s1_nu_mu.field
+          s2g := s1_mu_nu.field
+          resPtr[] := ybar * s2g * s1g.adj,
+    )
+    fail += res.failed
+
+  echo "\n  Testing Term 2: f1[x] += g2[x] s1g[x] c[x-ν]†"
+  block:
+    let res = runAdjointIdentity(
+      cfg = cfgBase,
+      makeBase = makeBase,
+      makeDir = makeDir,
+      jvp = proc(x: int; dx: Fld; res: var Fld) =
+        var s1_nu_mu = newShifter(g[nu], mu, 1)
+        var sc = newShifter(dx, nu, 1)
+        var s1g: Fld
+        s1g.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_nu_mu ^*! g[nu]
+          discard sc ^*! dx
+          s1g := s1_nu_mu.field
+          resPtr[] := g[mu] * s1g * sc.field.adj,
+      vjp = proc(x: int; ybar: Fld; res: var Fld) =
+        var s1_nu_mu = newShifter(g[nu], mu, 1)
+        var sm1_nu = newShifter(g[nu], nu, -1)
+        var tm1, s1g: Fld
+        tm1.new(lo)
+        s1g.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_nu_mu ^*! g[nu]
+          s1g := s1_nu_mu.field
+          tm1 := ybar.adj * g[mu] * s1g
+          threadBarrier()
+          discard sm1_nu ^*! tm1
+          threadBarrier()
+          resPtr[] := sm1_nu.field,
+    )
+    fail += res.failed
+
+  echo "\n  Testing Term 3: f2[x] += g1[x] c[x-ν] s1g[x]†"
+  block:
+    let res = runAdjointIdentity(
+      cfg = cfgBase,
+      makeBase = makeBase,
+      makeDir = makeDir,
+      jvp = proc(x: int; dx: Fld; res: var Fld) =
+        var s1_nu_mu = newShifter(g[nu], mu, 1)
+        var sc = newShifter(dx, nu, 1)
+        var s1g: Fld
+        s1g.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_nu_mu ^*! g[nu]
+          discard sc ^*! dx
+          s1g := s1_nu_mu.field
+          resPtr[] := g[nu] * sc.field * s1g.adj,
+      vjp = proc(x: int; ybar: Fld; res: var Fld) =
+        var s1_nu_mu = newShifter(g[nu], mu, 1)
+        var sm1_nu = newShifter(g[nu], nu, -1)
+        var tm1, s1g: Fld
+        tm1.new(lo)
+        s1g.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_nu_mu ^*! g[nu]
+          s1g := s1_nu_mu.field
+          tm1 := g[nu].adj * ybar * s1g
+          threadBarrier()
+          discard sm1_nu ^*! tm1
+          threadBarrier()
+          resPtr[] := sm1_nu.field,
+    )
+    fail += res.failed
+
+  echo "\n  Testing Term 4: f1[x] += g2[x+μ]† g1[x+μ] c[x+μ-ν]"
+  block:
+    let res = runAdjointIdentity(
+      cfg = cfgBase,
+      makeBase = makeBase,
+      makeDir = makeDir,
+      jvp = proc(x: int; dx: Fld; res: var Fld) =
+        var sc = newShifter(dx, nu, 1)
+        var sm1_mu = newShifter(g[mu], mu, -1)
+        var tm2: Fld
+        tm2.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard sc ^*! dx
+          tm2 := g[mu].adj * g[nu] * sc.field
+          threadBarrier()
+          discard sm1_mu ^*! tm2
+          threadBarrier()
+          resPtr[] := sm1_mu.field,
+      vjp = proc(x: int; ybar: Fld; res: var Fld) =
+        var s1_nu_mu = newShifter(g[nu], mu, 1)
+        var sm1_nu = newShifter(g[nu], nu, -1)
+        var tm1: Fld
+        tm1.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_nu_mu ^*! ybar
+          threadBarrier()
+          tm1 := g[nu].adj * g[mu] * s1_nu_mu.field
+          threadBarrier()
+          discard sm1_nu ^*! tm1
+          threadBarrier()
+          resPtr[] := sm1_nu.field,
+    )
+    fail += res.failed
+
+  echo "\n  Testing Term 5: f1[x] += c[x+μ]† g1[x+μ] g2[x+μ-ν]"
+  block:
+    let res = runAdjointIdentity(
+      cfg = cfgBase,
+      makeBase = makeBase,
+      makeDir = makeDir,
+      jvp = proc(x: int; dx: Fld; res: var Fld) =
+        var s1_mu_nu = newShifter(g[mu], nu, 1)
+        var sm1_mu = newShifter(g[mu], mu, -1)
+        var s2g, tm2: Fld
+        s2g.new(lo)
+        tm2.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_mu_nu ^*! g[mu]
+          s2g := s1_mu_nu.field
+          tm2 := dx.adj * g[nu] * s2g
+          threadBarrier()
+          discard sm1_mu ^*! tm2
+          threadBarrier()
+          resPtr[] := sm1_mu.field,
+      vjp = proc(x: int; ybar: Fld; res: var Fld) =
+        var s1_nu_mu = newShifter(g[nu], mu, 1)
+        var s1_mu_nu = newShifter(g[mu], nu, 1)
+        var s2g: Fld
+        s2g.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_nu_mu ^*! ybar
+          discard s1_mu_nu ^*! g[mu]
+          s2g := s1_mu_nu.field
+          resPtr[] := g[nu] * s2g * s1_nu_mu.field.adj,
+    )
+    fail += res.failed
+
+  echo "\n  Testing Term 6: f2[x] += g1[x+ν]† c[x+ν] g1[x+ν-μ]"
+  block:
+    let res = runAdjointIdentity(
+      cfg = cfgBase,
+      makeBase = makeBase,
+      makeDir = makeDir,
+      jvp = proc(x: int; dx: Fld; res: var Fld) =
+        var s1_nu_mu = newShifter(g[nu], mu, 1)
+        var sm1_nu = newShifter(g[nu], nu, -1)
+        var s1g, tm1: Fld
+        s1g.new(lo)
+        tm1.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_nu_mu ^*! g[nu]
+          s1g := s1_nu_mu.field
+          tm1 := g[nu].adj * dx * s1g
+          threadBarrier()
+          discard sm1_nu ^*! tm1
+          threadBarrier()
+          resPtr[] := sm1_nu.field,
+      vjp = proc(x: int; ybar: Fld; res: var Fld) =
+        var s1_nu_mu = newShifter(g[nu], mu, 1)
+        var s1_mu_nu = newShifter(g[mu], nu, 1)
+        var s1g: Fld
+        s1g.new(lo)
+        let resPtr = cast[ptr Fld](unsafeAddr(res))
+        threads:
+          discard s1_mu_nu ^*! ybar
+          discard s1_nu_mu ^*! g[nu]
+          s1g := s1_nu_mu.field
+          resPtr[] := g[nu] * s1_mu_nu.field * s1g.adj,
+    )
+    fail += res.failed
+
+  echo "\n  Summary: ", fail, " terms failed"
+  result = fail
+
+## First, verify the basic adjoint formula for f = M c†
+proc testBasicAdjoint(): int =
+  type Fld = type(g[0])
+
+  var M, c: Fld
+  M.new(lo)
+  c.new(lo)
+
+  threads:
+    M.gaussian r
+    c.gaussian r
+  let cfg = initTestConfig(
+    name = "basic adjoint f = M c†",
+    samples = 1,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let res = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): int = 0,
+    makeDir = proc(sample: int; x: int): Fld = c,
+    jvp = proc(x: int; dx: Fld; res: var Fld) =
+      let resPtr = cast[ptr Fld](unsafeAddr(res))
+      threads:
+        resPtr[] := M * dx.adj,
+    vjp = proc(x: int; ybar: Fld; res: var Fld) =
+      let resPtr = cast[ptr Fld](unsafeAddr(res))
+      threads:
+        resPtr[] := ybar.adj * M,
+  )
+  result = res.failed
+
+## Test multiple (mu, nu) pairs
+
+proc testSymStapleTangentAdjAllDirs(): int =
+  echo "\n### Testing symStapleJVPVJP for all direction pairs ###"
+  let cfgBase = initTestConfig(
+    name = "symStapleJVPVJP adjoint identity (all dirs)",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = false
+  )
+  var fail = 0
+  let alp = 0.5
+
+  type Fld = type(g[0])
+  var tm1, tm2: Fld
+  tm1.new(lo)
+  tm2.new(lo)
+
+  for mu in 0..<4:
+    for nu in 0..<4:
+      if nu == mu: continue
+
+      var s1 = newShifter(g[nu], mu, 1)
+      var s2 = newShifter(g[mu], nu, 1)
+      var shiftedDsbar = newShifter(g[nu], nu, 1)
+      var sm1 = newShifter(g[0], nu, -1)
+      var sm2 = newShifter(g[0], mu, -1)
+
+      let cfg = scopedCfg(
+        "symStapleJVPVJP adjoint (mu=" & $mu & ", nu=" & $nu & ")",
+        cfgBase
+      )
+
+      let res = runAdjointIdentity(
+        cfg = cfg,
+        makeBase = proc(sample: int): int =
+          0,
+        makeDir = proc(sample: int; x: int): Pair[Fld, Fld] =
+          var dg1, dg2: Fld
+          dg1.new(lo)
+          dg2.new(lo)
+          dg1.gaussian r
+          dg2.gaussian r
+          makePair(dg1, dg2),
+        jvp = proc(x: int; dx: Pair[Fld, Fld]; res: var Fld) =
+          var ds1 = newShifter(dx.a, mu, 1)
+          var ds2 = newShifter(dx.b, nu, 1)
+          discard s1 ^*! g[nu]
+          discard s2 ^*! g[mu]
+          discard ds1 ^*! dx.a
+          discard ds2 ^*! dx.b
+          res := 0
+          symStapleJVP(res, alp, g[nu], g[mu], s1, s2, dx.a, dx.b, ds1, ds2, tm1, sm1),
+        vjp = proc(x: int; ybar: Fld; res: var Pair[Fld, Fld]) =
+          discard s1 ^*! g[nu]
+          discard s2 ^*! g[mu]
+          res.a := 0
+          res.b := 0
+          symStapleJVPVJP(res.a, res.b, alp, g[nu], g[mu], s1, s2,
+                          ybar, shiftedDsbar, tm1, tm2, sm1, sm2),
+      )
+      if res.failed == 0:
+        echo "  (mu=", mu, ", nu=", nu, ") Passed"
+      else:
+        echo "  (mu=", mu, ", nu=", nu, ") FAILED"
+        inc fail
+
+  result = fail
+
+proc testSymStapleTangentAdjTerms(): int =
+  echo "\n### Testing symStapleJVPVJP term adjoints (A–F) ###"
+  let mu = 0
+  let nu = 1
+  let alp = 0.5
+
+  type Fld = type(g[0])
+
+  proc randFld(): Fld =
+    var x: Fld
+    x.new(lo)
+    x.gaussian r
+    x
+
+  type TermDesc = object
+    name: string
+    jvp: proc(dx: Fld; res: var Fld)
+    vjp: proc(ybar: Fld; res: var Fld)
+
+  let terms = @[
+    TermDesc(
+      name: "Term A",
+      jvp: proc(dx: Fld; res: var Fld) =
+        var s1 = newShifter(g[nu], mu, 1)
+        var sm = newShifter(g[0], nu, -1)
+        var tm: Fld
+        tm.new(lo)
+        discard s1 ^*! g[nu]
+        tm := dx.adj * g[mu] * s1.field
+        discard sm ^*! tm
+        res := alp * sm.field,
+      vjp: proc(ybar: Fld; res: var Fld) =
+        var sf = newShifter(g[0], nu, 1)
+        var s1 = newShifter(g[nu], mu, 1)
+        discard sf ^*! ybar
+        discard s1 ^*! g[nu]
+        res := alp * (g[mu] * s1.field * sf.field.adj)
+    ),
+    TermDesc(
+      name: "Term B",
+      jvp: proc(dx: Fld; res: var Fld) =
+        var s1 = newShifter(g[nu], mu, 1)
+        var s2 = newShifter(g[mu], nu, 1)
+        discard s1 ^*! g[nu]
+        discard s2 ^*! g[mu]
+        res := alp * (dx * s2.field * s1.field.adj),
+      vjp: proc(ybar: Fld; res: var Fld) =
+        var s1 = newShifter(g[nu], mu, 1)
+        var s2 = newShifter(g[mu], nu, 1)
+        discard s1 ^*! g[nu]
+        discard s2 ^*! g[mu]
+        res := alp * (ybar * s1.field * s2.field.adj)
+    ),
+    TermDesc(
+      name: "Term C",
+      jvp: proc(dx: Fld; res: var Fld) =
+        var s1 = newShifter(g[nu], mu, 1)
+        var sm = newShifter(g[0], nu, -1)
+        var tm: Fld
+        tm.new(lo)
+        discard s1 ^*! g[nu]
+        tm := g[nu].adj * dx * s1.field
+        discard sm ^*! tm
+        res := alp * sm.field,
+      vjp: proc(ybar: Fld; res: var Fld) =
+        var sf = newShifter(g[0], nu, 1)
+        var s1 = newShifter(g[nu], mu, 1)
+        discard sf ^*! ybar
+        discard s1 ^*! g[nu]
+        res := alp * (g[nu] * sf.field * s1.field.adj)
+    ),
+    TermDesc(
+      name: "Term D",
+      jvp: proc(dx: Fld; res: var Fld) =
+        var s1 = newShifter(g[nu], mu, 1)
+        var sm1 = newShifter(g[0], nu, -1)
+        var ds1 = newShifter(dx, mu, 1)
+        var tm1: Fld
+        tm1.new(lo)
+        discard s1 ^*! g[nu]
+        discard ds1 ^*! dx
+        tm1 := g[nu].adj * g[mu] * ds1.field
+        discard sm1 ^*! tm1
+        res := alp * sm1.field,
+      vjp: proc(ybar: Fld; res: var Fld) =
+        var s2 = newShifter(g[mu], nu, 1)
+        var sm2 = newShifter(g[0], mu, -1)
+        var tm2: Fld
+        tm2.new(lo)
+        discard s2 ^*! ybar
+        tm2 := g[mu].adj * g[nu] * s2.field
+        discard sm2 ^*! tm2
+        res := alp * sm2.field
+    ),
+    TermDesc(
+      name: "Term E",
+      jvp: proc(dx: Fld; res: var Fld) =
+        var s1 = newShifter(g[nu], mu, 1)
+        var ds2 = newShifter(dx, nu, 1)
+        discard s1 ^*! g[nu]
+        discard ds2 ^*! dx
+        res := alp * (g[nu] * ds2.field * s1.field.adj),
+      vjp: proc(ybar: Fld; res: var Fld) =
+        var s1 = newShifter(g[nu], mu, 1)
+        var sm1 = newShifter(g[0], nu, -1)
+        var tm: Fld
+        tm.new(lo)
+        discard s1 ^*! g[nu]
+        tm := g[nu].adj * ybar * s1.field
+        discard sm1 ^*! tm
+        res := alp * sm1.field
+    ),
+    TermDesc(
+      name: "Term F",
+      jvp: proc(dx: Fld; res: var Fld) =
+        var s2 = newShifter(g[mu], nu, 1)
+        var ds1 = newShifter(dx, mu, 1)
+        discard s2 ^*! g[mu]
+        discard ds1 ^*! dx
+        res := alp * (g[nu] * s2.field * ds1.field.adj),
+      vjp: proc(ybar: Fld; res: var Fld) =
+        var s2 = newShifter(g[mu], nu, 1)
+        var sm2 = newShifter(g[0], mu, -1)
+        var tm: Fld
+        tm.new(lo)
+        discard s2 ^*! g[mu]
+        tm := ybar.adj * g[nu] * s2.field
+        discard sm2 ^*! tm
+        res := alp * sm2.field
+    )
+  ]
+
+  var fail = 0
+  for term in terms:
+    let cfg = initTestConfig(
+      name = term.name,
+      samples = 3,
+      atol = 1e-12,
+      rtol = 1e-10,
+      verbose = true
+    )
+    let t = term
+    let res = runAdjointIdentity(
+      cfg = cfg,
+      makeBase = proc(sample: int): int =
+        0,
+      makeDir = proc(sample: int; x: int): Fld =
+        randFld(),
+      jvp = proc(x: int; dx: Fld; res: var Fld) =
+        t.jvp(dx, res),
+      vjp = proc(x: int; ybar: Fld; res: var Fld) =
+        t.vjp(ybar, res),
+    )
+    fail += res.failed
+
+  ## Combined A+B+C manually
+  block:
+    echo "\n### Testing Combined A+B+C manually ###"
+    var s1 = newShifter(g[nu], mu, 1)
+    var s2 = newShifter(g[mu], nu, 1)
+    var sm = newShifter(g[0], nu, -1)
+    var sf = newShifter(g[0], nu, 1)
+    var tm: Fld
+    tm.new(lo)
+    let cfg = initTestConfig(
+      name = "Combined A+B+C",
+      samples = 3,
+      atol = 1e-12,
+      rtol = 1e-10,
+      verbose = true
+    )
+    let res = runAdjointIdentity(
+      cfg = cfg,
+      makeBase = proc(sample: int): int =
+        0,
+      makeDir = proc(sample: int; x: int): Pair[Fld, Fld] =
+        makePair(randFld(), randFld()),
+      jvp = proc(x: int; dx: Pair[Fld, Fld]; res: var Fld) =
+        discard s1 ^*! g[nu]
+        discard s2 ^*! g[mu]
+        res := 0
+        tm := dx.a.adj * g[mu] * s1.field
+        discard sm ^*! tm
+        res += alp * sm.field
+        res += alp * (dx.a * s2.field * s1.field.adj)
+        tm := g[nu].adj * dx.b * s1.field
+        discard sm ^*! tm
+        res += alp * sm.field,
+      vjp = proc(x: int; ybar: Fld; res: var Pair[Fld, Fld]) =
+        discard sf ^*! ybar
+        discard s1 ^*! g[nu]
+        discard s2 ^*! g[mu]
+        res.a := 0
+        res.b := 0
+        res.a += alp * (g[mu] * s1.field * sf.field.adj)
+        res.a += alp * (ybar * s1.field * s2.field.adj)
+        res.b += alp * (g[nu] * sf.field * s1.field.adj),
+    )
+    fail += res.failed
+
+  ## Using symStapleJVP and symStapleJVPVJP
+  block:
+    echo "\n### Testing with symStapleJVP and symStapleJVPVJP ###"
+    var s1 = newShifter(g[nu], mu, 1)
+    var s2 = newShifter(g[mu], nu, 1)
+    var shiftedDsbar = newShifter(g[nu], nu, 1)
+    var sm1 = newShifter(g[0], nu, -1)
+    var sm2 = newShifter(g[0], mu, -1)
+    var tm1, tm2: Fld
+    tm1.new(lo)
+    tm2.new(lo)
+    let cfg = initTestConfig(
+      name = "symStapleJVP/JVPVJP adjoint",
+      samples = 3,
+      atol = 1e-12,
+      rtol = 1e-10,
+      verbose = true
+    )
+    let res = runAdjointIdentity(
+      cfg = cfg,
+      makeBase = proc(sample: int): int =
+        0,
+      makeDir = proc(sample: int; x: int): Pair[Fld, Fld] =
+        makePair(randFld(), randFld()),
+      jvp = proc(x: int; dx: Pair[Fld, Fld]; res: var Fld) =
+        var ds1 = newShifter(dx.a, mu, 1)
+        var ds2 = newShifter(dx.b, nu, 1)
+        discard s1 ^*! g[nu]
+        discard s2 ^*! g[mu]
+        discard ds1 ^*! dx.a
+        discard ds2 ^*! dx.b
+        res := 0
+        symStapleJVP(res, alp, g[nu], g[mu], s1, s2, dx.a, dx.b, ds1, ds2, tm1, sm1),
+      vjp = proc(x: int; ybar: Fld; res: var Pair[Fld, Fld]) =
+        discard s1 ^*! g[nu]
+        discard s2 ^*! g[mu]
+        res.a := 0
+        res.b := 0
+        symStapleJVPVJP(res.a, res.b, alp, g[nu], g[mu], s1, s2,
+                        ybar, shiftedDsbar, tm1, tm2, sm1, sm2),
+    )
+    fail += res.failed
+
+  result = fail
+
+## Test all (mu, nu) pairs
+
+proc testSymStapleDeriv2AdjAllDirs(): int =
+  echo "\n### Testing symStapleHVPVJP for all direction pairs ###"
+  let cfgBase = initTestConfig(
+    name = "symStapleHVPVJP adjoint identity (all dirs)",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = false
+  )
+  var fail = 0
+
+  type Fld = type(g[0])
+  var tm1, tm2, acc1, acc2: Fld
+  tm1.new(lo)
+  tm2.new(lo)
+  acc1.new(lo)
+  acc2.new(lo)
+
+  for mu in 0..<4:
+    for nu in 0..<4:
+      if nu == mu: continue
+
+      var s1 = newShifter(g[nu], mu, 1)
+      var s2 = newShifter(g[mu], nu, 1)
+      var shiftedF2bar = newShifter(g[nu], nu, 1)
+      var shiftedF1bar = newShifter(g[mu], mu, 1)
+      var sm1 = newShifter(g[0], nu, -1)
+      var sm2 = newShifter(g[0], mu, -1)
+
+      var c: Fld
+      c.new(lo)
+      c.gaussian r
+      var sc = newShifter(c, nu, 1)
+
+      let cfg = scopedCfg(
+        "symStapleHVPVJP adjoint (mu=" & $mu & ", nu=" & $nu & ")",
+        cfgBase
+      )
+
+      let res = runAdjointIdentity(
+        cfg = cfg,
+        makeBase = proc(sample: int): int =
+          0,
+        makeDir = proc(sample: int; x: int): H3[Fld] =
+          var dg1, dg2, dc: Fld
+          dg1.new(lo)
+          dg2.new(lo)
+          dc.new(lo)
+          dg1.gaussian r
+          dg2.gaussian r
+          dc.gaussian r
+          makeH3(dg1, dg2, dc),
+        jvp = proc(x: int; dx: H3[Fld]; res: var Pair[Fld, Fld]) =
+          var ds1 = newShifter(dx.a, mu, 1)
+          var ds2 = newShifter(h2(dx), nu, 1)
+          var dsc = newShifter(h3(dx), nu, 1)
+          discard s1 ^*! g[nu]
+          discard s2 ^*! g[mu]
+          discard sc ^*! c
+          discard ds1 ^*! dx.a
+          discard ds2 ^*! h2(dx)
+          discard dsc ^*! h3(dx)
+          res.a := 0
+          res.b := 0
+          acc1 := 0
+          acc2 := 0
+          symStapleHVP(res.a, res.b, acc1, acc2, g[nu], g[mu], s1, s2,
+                       c, sc, dx.a, h2(dx), h3(dx), ds1, ds2, dsc, tm1, tm2, sm1, sm2),
+        vjp = proc(x: int; ybar: Pair[Fld, Fld]; res: var H3[Fld]) =
+          discard s1 ^*! g[nu]
+          discard s2 ^*! g[mu]
+          discard sc ^*! c
+          res.a := 0
+          h2(res) := 0
+          h3(res) := 0
+          symStapleHVPVJP(res.a, h2(res), h3(res), g[nu], g[mu], s1, s2,
+                          c, sc, ybar.a, ybar.b, shiftedF2bar, shiftedF1bar, tm1, tm2, sm1, sm2),
+      )
+      if res.failed == 0:
+        echo "  (mu=", mu, ", nu=", nu, ") Passed"
+      else:
+        echo "  (mu=", mu, ", nu=", nu, ") FAILED"
+        inc fail
+
+  result = fail
+
+proc testSymStapleDeriv2AdjTerms(): int =
+  echo "\n### Testing symStapleHVPVJP term adjoints (1–10) ###"
+  let mu = 0
+  let nu = 1
+  type Fld = type(g[0])
+
+  proc randFld(): Fld =
+    var x: Fld
+    x.new(lo)
+    x.gaussian r
+    x
+
+  type TermDesc = object
+    name: string
+    jvp: proc(dx: Fld; res: var Fld)
+    vjp: proc(ybar: Fld; res: var Fld)
+
+  let terms = @[
+    block:
+      var s1 = newShifter(g[nu], mu, 1)
+      var sc = newShifter(g[0], nu, 1)
+      var c = randFld()
+      TermDesc(
+        name: "Term 1",
+        jvp: proc(dx: Fld; res: var Fld) =
+          discard s1 ^*! g[nu]
+          discard sc ^*! c
+          res := dx * s1.field * sc.field.adj,
+        vjp: proc(ybar: Fld; res: var Fld) =
+          discard s1 ^*! g[nu]
+          discard sc ^*! c
+          res := ybar * sc.field * s1.field.adj
+      ),
+    block:
+      var sc = newShifter(g[0], nu, 1)
+      var sm2 = newShifter(g[0], mu, -1)
+      var c = randFld()
+      var tm: Fld
+      tm.new(lo)
+      TermDesc(
+        name: "Term 2",
+        jvp: proc(dx: Fld; res: var Fld) =
+          var ds1 = newShifter(dx, mu, 1)
+          discard sc ^*! c
+          discard ds1 ^*! dx
+          res := g[mu] * ds1.field * sc.field.adj,
+        vjp: proc(ybar: Fld; res: var Fld) =
+          discard sc ^*! c
+          tm := g[mu].adj * ybar * sc.field
+          discard sm2 ^*! tm
+          res := sm2.field
+      ),
+    block:
+      var s1 = newShifter(g[nu], mu, 1)
+      var sm1 = newShifter(g[0], nu, -1)
+      var tm: Fld
+      tm.new(lo)
+      TermDesc(
+        name: "Term 3",
+        jvp: proc(dx: Fld; res: var Fld) =
+          var dsc = newShifter(dx, nu, 1)
+          discard s1 ^*! g[nu]
+          discard dsc ^*! dx
+          res := g[mu] * s1.field * dsc.field.adj,
+        vjp: proc(ybar: Fld; res: var Fld) =
+          discard s1 ^*! g[nu]
+          tm := ybar.adj * g[mu] * s1.field
+          discard sm1 ^*! tm
+          res := sm1.field
+      ),
+    block:
+      var s1 = newShifter(g[nu], mu, 1)
+      var s2 = newShifter(g[mu], nu, 1)
+      TermDesc(
+        name: "Term 4",
+        jvp: proc(dx: Fld; res: var Fld) =
+          discard s1 ^*! g[nu]
+          discard s2 ^*! g[mu]
+          res := dx * s1.field * s2.field.adj,
+        vjp: proc(ybar: Fld; res: var Fld) =
+          discard s1 ^*! g[nu]
+          discard s2 ^*! g[mu]
+          res := ybar * s2.field * s1.field.adj
+      ),
+    block:
+      var s2 = newShifter(g[mu], nu, 1)
+      var sm2 = newShifter(g[0], mu, -1)
+      var c = randFld()
+      var tm: Fld
+      tm.new(lo)
+      TermDesc(
+        name: "Term 5",
+        jvp: proc(dx: Fld; res: var Fld) =
+          var ds1 = newShifter(dx, mu, 1)
+          discard s2 ^*! g[mu]
+          discard ds1 ^*! dx
+          res := c * ds1.field * s2.field.adj,
+        vjp: proc(ybar: Fld; res: var Fld) =
+          discard s2 ^*! g[mu]
+          tm := c.adj * ybar * s2.field
+          discard sm2 ^*! tm
+          res := sm2.field
+      ),
+    block:
+      var s1 = newShifter(g[nu], mu, 1)
+      var sm1 = newShifter(g[0], nu, -1)
+      var c = randFld()
+      var tm: Fld
+      tm.new(lo)
+      TermDesc(
+        name: "Term 6",
+        jvp: proc(dx: Fld; res: var Fld) =
+          var ds2 = newShifter(dx, nu, 1)
+          discard s1 ^*! g[nu]
+          discard ds2 ^*! dx
+          res := c * s1.field * ds2.field.adj,
+        vjp: proc(ybar: Fld; res: var Fld) =
+          discard s1 ^*! g[nu]
+          tm := ybar.adj * c * s1.field
+          discard sm1 ^*! tm
+          res := sm1.field
+      ),
+    block:
+      var s1 = newShifter(g[nu], mu, 1)
+      var sc = newShifter(g[0], nu, 1)
+      var c = randFld()
+      TermDesc(
+        name: "Term 8",
+        jvp: proc(dx: Fld; res: var Fld) =
+          discard s1 ^*! g[nu]
+          discard sc ^*! c
+          res := dx * sc.field * s1.field.adj,
+        vjp: proc(ybar: Fld; res: var Fld) =
+          discard s1 ^*! g[nu]
+          discard sc ^*! c
+          res := ybar * s1.field * sc.field.adj
+      ),
+    block:
+      var s1 = newShifter(g[nu], mu, 1)
+      var sm1 = newShifter(g[0], nu, -1)
+      var tm: Fld
+      tm.new(lo)
+      TermDesc(
+        name: "Term 9",
+        jvp: proc(dx: Fld; res: var Fld) =
+          var dsc = newShifter(dx, nu, 1)
+          discard s1 ^*! g[nu]
+          discard dsc ^*! dx
+          res := g[nu] * dsc.field * s1.field.adj,
+        vjp: proc(ybar: Fld; res: var Fld) =
+          discard s1 ^*! g[nu]
+          tm := g[nu].adj * ybar * s1.field
+          discard sm1 ^*! tm
+          res := sm1.field
+      ),
+    block:
+      var sc = newShifter(g[0], nu, 1)
+      var sm2 = newShifter(g[0], mu, -1)
+      var c = randFld()
+      var tm: Fld
+      tm.new(lo)
+      TermDesc(
+        name: "Term 10",
+        jvp: proc(dx: Fld; res: var Fld) =
+          var ds1 = newShifter(dx, mu, 1)
+          discard sc ^*! c
+          discard ds1 ^*! dx
+          res := g[nu] * sc.field * ds1.field.adj,
+        vjp: proc(ybar: Fld; res: var Fld) =
+          discard sc ^*! c
+          tm := ybar.adj * g[nu] * sc.field
+          discard sm2 ^*! tm
+          res := sm2.field
+      )
+  ]
+
+  var fail = 0
+  for term in terms:
+    let cfg = initTestConfig(
+      name = term.name,
+      samples = 3,
+      atol = 1e-12,
+      rtol = 1e-10,
+      verbose = true
+    )
+    let t = term
+    let res = runAdjointIdentity(
+      cfg = cfg,
+      makeBase = proc(sample: int): int =
+        0,
+      makeDir = proc(sample: int; x: int): Fld =
+        randFld(),
+      jvp = proc(x: int; dx: Fld; res: var Fld) =
+        t.jvp(dx, res),
+      vjp = proc(x: int; ybar: Fld; res: var Fld) =
+        t.vjp(ybar, res),
+    )
+    fail += res.failed
+
+  result = fail
+
+var fail = 0
+# Section A: baseline FD
+fail += testSymStapleJvpFD()
+fail += testSymStapleHvpFD()
+# Section B: JVP/HVP FD
+fail += testSymStapleDeriv2Full()
+fail += testIsolatedG1()
+fail += testIsolatedG2()
+fail += testIsolatedC()
+fail += testSymStapleDeriv()
+# Section C: adjoint identities
+fail += testSymStapleDerivAdjChain()
+fail += testSymStapleTangentAdjAllDirs()
+fail += testSymStapleDeriv2AdjAllDirs()
+# Section D: term-by-term checks
+fail += testSymStapleDerivTermByTerm()
+fail += testSymStapleTangentAdjTerms()
+fail += testSymStapleDeriv2AdjTerms()
+# Section E: diagnostics
+fail += testBasicAdjoint()
+
+if fail == 0:
+  qexFinalize()
+else:
+  qexAbort(fail)
diff --git a/tests/deriv/utils.nim b/tests/deriv/utils.nim
new file mode 100644
index 00000000..d7d6a6c5
--- /dev/null
+++ b/tests/deriv/utils.nim
@@ -0,0 +1,800 @@
+import math
+import os
+import random
+import sequtils
+import macros
+import algorithms/numdiff
+import maths/matrixFunctions
+import qex
+import gauge/gaugeUtils
+import gauge/stoutsmear
+
+const
+  defaultSamples = 5
+  defaultEps = 1e-2
+  defaultScale = 2.0
+  defaultAtol = 1e-6
+  defaultRtol = 1e-5
+  defaultFdFactor = 3.0
+  defaultVerbose = true
+  actionForceDefaultEps = 0.125
+  actionForceDefaultAtol = 5e-8
+  actionForceDefaultRtol = 1e-7
+  actionForceDefaultFdFactor = 4.0
+
+type
+  TestConfig* = object
+    name*: string
+    samples*: int
+    eps*: float
+    scale*: float
+    atol*: float
+    rtol*: float
+    fdFactor*: float
+    verbose*: bool
+
+  TestResult* = object
+    name*: string
+    passed*: int
+    failed*: int
+
+  GaugeTestEnv*[L, G, R] = object
+    lo*: L
+    g*: G
+    r*: R
+    lat*: seq[int]
+    gaugefile*: string
+    seed*: uint64
+    hasFile*: bool
+
+  Pair*[A, B] = object
+    a*: A
+    b*: B
+
+
+  AcceptFD* = proc(
+    cfg: TestConfig;
+    ana, fd, err, fdErr, refVal: float;
+    sample: int
+  ): bool
+
+proc initTestConfig*(
+    name: string;
+    samples = defaultSamples;
+    eps = defaultEps;
+    scale = defaultScale;
+    atol = defaultAtol;
+    rtol = defaultRtol;
+    fdFactor = defaultFdFactor;
+    verbose = defaultVerbose
+  ): TestConfig =
+  result.name = name
+  result.samples = samples
+  result.eps = eps
+  result.scale = scale
+  result.atol = atol
+  result.rtol = rtol
+  result.fdFactor = fdFactor
+  result.verbose = verbose
+
+proc add(acc: var TestResult, other: TestResult) =
+  if acc.name.len == 0:
+    acc.name = other.name
+  acc.passed += other.passed
+  acc.failed += other.failed
+
+proc reportSummary*(r: TestResult) =
+  if r.name.len > 0:
+    if r.failed == 0:
+      echo r.name, ": all ", r.passed, " tests passed"
+    else:
+      echo r.name, ": ", r.failed, " failed (", r.passed, " passed)"
+
+proc reportBanner*(name: string) =
+  if name.len > 0:
+    echo "### Testing ", name
+
+proc reportBanner*(cfg: TestConfig) =
+  reportBanner(cfg.name)
+
+proc makePair*[A, B](a: A; b: B): Pair[A, B] =
+  Pair[A, B](a: a, b: b)
+
+proc seedFromDir*[Y, DX](dx: DX): Y =
+  when Y is Pair:
+    when DX is Pair:
+      result = makePair(
+        seedFromDir[typeof(default(Y).a), typeof(default(DX).a)](dx.a),
+        seedFromDir[typeof(default(Y).b), typeof(default(DX).b)](dx.b)
+      )
+    else:
+      result = makePair(
+        seedFromDir[typeof(default(Y).a), DX](dx),
+        seedFromDir[typeof(default(Y).b), DX](dx)
+      )
+  else:
+    when Y is DX:
+      result = allocLike(dx)
+      copyLike(result, dx)
+    elif DX is Pair:
+      result = seedFromDir[Y, typeof(default(DX).a)](dx.a)
+    else:
+      {.error: "seedFromDir requires Y to be DX or derived from Pair DX".}
+
+proc allocLike*[T](x: T): T =
+  when T is Pair:
+    Pair[typeof(allocLike(x.a)), typeof(allocLike(x.b))](
+      a: allocLike(x.a),
+      b: allocLike(x.b)
+    )
+  elif compiles(newOneOf(x)):
+    newOneOf(x)
+  else:
+    var y: T
+    y
+
+
+proc zeroLike*[T](x: T): T =
+  when T is Pair:
+    Pair[typeof(zeroLike(x.a)), typeof(zeroLike(x.b))](
+      a: zeroLike(x.a),
+      b: zeroLike(x.b)
+    )
+  else:
+    var y = allocLike(x)
+    when compiles(y := 0):
+      y := 0
+    elif compiles(assignM(y, 0)):
+      assignM(y, 0)
+    elif compiles(y = 0):
+      y = 0
+    else:
+      discard
+    y
+
+
+proc copyLike*[T](dst: var T; src: T) =
+  when T is Pair:
+    copyLike(dst.a, src.a)
+    copyLike(dst.b, src.b)
+  elif compiles(dst := src):
+    dst := src
+  elif compiles(assignM(dst, src)):
+    assignM(dst, src)
+  else:
+    dst = src
+
+
+proc dotLike*[T](a, b: T): float =
+  when T is Pair:
+    dotLike(a.a, b.a) + dotLike(a.b, b.b)
+  elif T is FieldArray:
+    dotFieldArray(a, b)
+  elif compiles(redot(a, b)):
+    redot(a, b)
+  elif T is seq or T is array:
+    var s = 0.0
+    for i in 0..<a.len:
+      s += dotLike(a[i], b[i])
+    s
+  else:
+    a * b
+
+proc dotFieldArray*[N:static[int],V:static[int],T](a, b: FieldArray[N,V,T]): float =
+  var s = 0.0
+  when N == 1:
+    for i in 0..<a.shape[0]:
+      let fa = a[i]
+      if fa != nil:
+        s += redot(fa, b[i])
+  elif N == 2:
+    for i in 0..<a.shape[0]:
+      for j in 0..<a.shape[1]:
+        let fa = a[i, j]
+        if fa != nil:
+          s += redot(fa, b[i, j])
+  else:
+    for i in 0..<a.arr.len:
+      let fa = a.arr[i]
+      if fa != nil:
+        s += redot(fa, b.arr[i])
+  s
+
+proc dotLike*[N:static[int],V:static[int],T](a, b: FieldArray[N,V,T]): float =
+  dotFieldArray(a, b)
+
+proc norm2Like*[T](x: T): float =
+  dotLike(x, x)
+
+proc perturbLike*[T](x: T; dx: T; eps: float; res: var T; useExp: static[bool] = true) =
+  when T is Pair:
+    perturbLike(x.a, dx.a, eps, res.a, useExp)
+    perturbLike(x.b, dx.b, eps, res.b, useExp)
+  else:
+    when useExp and compiles(addNoiseExp(eps, dx, x, res)):
+      addNoiseExp(eps, dx, x, res)
+    elif useExp and compiles(addNoiseExpField(eps, dx, x, res)):
+      addNoiseExpField(eps, dx, x, res)
+    elif compiles(perturbAdd(x, dx, eps, res)):
+      perturbAdd(x, dx, eps, res)
+    elif compiles(copyLike(res, x)):
+      copyLike(res, x)
+      when compiles(res += eps * dx):
+        res += eps * dx
+      else:
+        res = res + eps * dx
+    else:
+      res = x + eps * dx
+
+
+proc acceptTol*(cfg: TestConfig; err, fdErr, refVal: float): bool =
+  let tol = max(max(cfg.atol, cfg.rtol * refVal), cfg.fdFactor * fdErr)
+  err <= tol
+
+proc reportFD*(cfg: TestConfig; sample: int; ana, fd, err, fdErr: float; ok: bool) =
+  if ok:
+    if cfg.verbose:
+      echo "Test ", sample, " Passed: Ana=", ana, " FD=", fd,
+           " err=", err, " ±", fdErr
+  else:
+    echo "Test ", sample, " FAILED: Ana=", ana, " FD=", fd,
+         " err=", err, " ±", fdErr
+
+proc reportSimple(cfg: TestConfig; sample: int; lhs, rhs, err, rel: float; ok: bool) =
+  if ok:
+    if cfg.verbose:
+      echo "Test ", sample, " Passed: LHS=", lhs, " RHS=", rhs,
+           " err=", err, " rel=", rel
+  else:
+    echo "Test ", sample, " FAILED: LHS=", lhs, " RHS=", rhs,
+         " err=", err, " rel=", rel
+
+proc reportCompare*(
+    cfg: TestConfig;
+    sample: int;
+    lhs, rhs: float;
+    label = ""
+  ): bool =
+  if label.len > 0:
+    echo "  ", label
+  let err = abs(lhs - rhs)
+  let refVal = max(1.0, max(abs(lhs), abs(rhs)))
+  let rel = err / refVal
+  let ok = err <= max(cfg.atol, cfg.rtol * refVal)
+  reportSimple(cfg, sample, lhs, rhs, err, rel, ok)
+  ok
+
+proc captureFD*(
+    fdStore: ptr float;
+    fdeStore: ptr float
+  ): AcceptFD =
+  proc accept(
+      cfg: TestConfig;
+      ana, fd, err, fdErr, refVal: float;
+      sample: int
+    ): bool =
+    if fdStore != nil:
+      fdStore[] = fd
+    if fdeStore != nil:
+      fdeStore[] = fdErr
+    acceptTol(cfg, err, fdErr, refVal)
+  accept
+
+proc randMat*[MatT](rng: var Rand; scale = 1.0): MatT =
+  var m: MatT
+  for i in 0..<m.nrows:
+    for j in 0..<m.ncols:
+      m[i,j].re = scale * (rng.rand(1.0) - 0.5)
+      m[i,j].im = scale * (rng.rand(1.0) - 0.5)
+  m
+
+proc randTAH*[MatT](rng: var Rand; scale = 1.0): MatT =
+  var m = randMat[MatT](rng, scale)
+  m.projectTAH
+  m
+
+proc hermitianize*[MatT](m: MatT): MatT =
+  0.5 * (m + m.adj)
+
+proc perturbAdd*[MatT](x: MatT; dx: MatT; eps: float; res: var MatT) =
+  res := x
+  res += eps * dx
+
+# Runs finite-difference vs JVP for general X->Y maps (custom perturb/dot).
+# Check: d/d eps <p, f(x + eps*dx)>|0  ==  <p, J dx>.
+proc runFDJVP*(
+    cfg: TestConfig,
+    makeBase: auto,
+    makeDir: auto,
+    makeProbe: auto,
+    perturb: auto,
+    f: auto,
+    jvp: auto,
+    accept: AcceptFD = nil,
+    ordMax: static int = 6
+  ): TestResult =
+  reportBanner(cfg)
+  result.name = cfg.name
+  for sample in 0..<cfg.samples:
+    let base = makeBase(sample)
+    let dx = makeDir(sample, base)
+    let probe = makeProbe(sample, base)
+    var xPert = allocLike(base)
+    var y = allocLike(probe)
+    var dy = allocLike(probe)
+    proc F(eps: float): float =
+      perturb(base, dx, eps, xPert)
+      f(xPert, y)
+      dotLike(probe, y)
+    var fd, fde: float
+    ndiff(fd, fde, F, 0.0, cfg.eps, scale = cfg.scale, ordMax = ordMax)
+    jvp(base, dx, dy)
+    let ana = dotLike(probe, dy)
+    let err = abs(ana - fd)
+    let refVal = max(1.0, abs(fd))
+    let ok = if accept != nil:
+      accept(cfg, ana, fd, err, fde, refVal, sample)
+    else:
+      acceptTol(cfg, err, fde, refVal)
+    reportFD(cfg, sample, ana, fd, err, fde, ok)
+    if ok: inc result.passed else: inc result.failed
+
+# Convenience JVP FD check for common cases (default cfg + exp-perturb).
+# Check: d/d eps <p, f(x + eps*dx)>|0  ==  <p, J dx>.
+proc runFDJVPDefault*(
+    cfg: TestConfig,
+    makeBase: auto,
+    makeDir: auto,
+    makeProbe: auto,
+    f: auto,
+    jvp: auto,
+    accept: AcceptFD = nil,
+    ordMax: static int = 6
+  ): TestResult =
+  type X = typeof(makeBase(0))
+  type DX = typeof(makeDir(0, default(X)))
+  type Y = typeof(makeProbe(0, default(X)))
+  proc perturb(x: X; dx: DX; eps: float; res: var X) =
+    perturbLike(x, dx, eps, res, true)
+  runFDJVP(
+    cfg = cfg,
+    makeBase = makeBase,
+    makeDir = makeDir,
+    makeProbe = makeProbe,
+    perturb = perturb,
+    f = f,
+    jvp = jvp,
+    accept = accept,
+    ordMax = ordMax
+  )
+
+# Runs finite-difference vs VJP for general X->Y maps (custom perturb/dot).
+# Check: d/d eps <ybar, f(x + eps*dx)>|0  ==  <J^T ybar, dx>.
+# Runs finite-difference vs JVP for scalar-valued f (custom perturb).
+# Check: d/d eps f(x + eps*dx)|0  ==  J dx (directional derivative).
+proc runFDScalarJVP*(
+    cfg: TestConfig,
+    makeBase: auto,
+    makeDir: auto,
+    perturb: auto,
+    f: auto,
+    jvp: auto,
+    accept: AcceptFD = nil,
+    ordMax: static int = 6
+  ): TestResult =
+  reportBanner(cfg)
+  result.name = cfg.name
+  for sample in 0..<cfg.samples:
+    let base = makeBase(sample)
+    let dx = makeDir(sample, base)
+    var xPert = allocLike(base)
+    proc F(eps: float): float =
+      perturb(base, dx, eps, xPert)
+      var val: float
+      when compiles(f(xPert, val)):
+        f(xPert, val)
+        val
+      else:
+        f(xPert)
+    var fd, fde: float
+    ndiff(fd, fde, F, 0.0, cfg.eps, scale = cfg.scale, ordMax = ordMax)
+    var ana: float
+    when compiles(jvp(base, dx, ana)):
+      jvp(base, dx, ana)
+    else:
+      ana = jvp(base, dx)
+    let err = abs(ana - fd)
+    let refVal = max(1.0, abs(fd))
+    let ok = if accept != nil:
+      accept(cfg, ana, fd, err, fde, refVal, sample)
+    else:
+      acceptTol(cfg, err, fde, refVal)
+    reportFD(cfg, sample, ana, fd, err, fde, ok)
+    if ok: inc result.passed else: inc result.failed
+
+# Runs finite-difference vs JVP for scalar f with default exp-perturb.
+# Check: d/d eps f(x + eps*dx)|0  ==  J dx (directional derivative).
+proc runFDScalarJVPDefault*(
+    cfg: TestConfig,
+    makeBase: auto,
+    makeDir: auto,
+    f: auto,
+    jvp: auto,
+    accept: AcceptFD = nil,
+    ordMax: static int = 6
+  ): TestResult =
+  type X = typeof(makeBase(0))
+  type DX = typeof(makeDir(0, default(X)))
+  proc perturb(x: X; dx: DX; eps: float; res: var X) =
+    perturbLike(x, dx, eps, res, true)
+  runFDScalarJVP(
+    cfg = cfg,
+    makeBase = makeBase,
+    makeDir = makeDir,
+    perturb = perturb,
+    f = f,
+    jvp = jvp,
+    accept = accept,
+    ordMax = ordMax
+  )
+
+macro jvpResType(jvp: typed): untyped =
+  let t = jvp.getTypeInst
+  let procTy = if t.kind == nnkProcTy: t else: t.getTypeInst
+  let params = procTy[0]
+  if params.len < 4:
+    error("jvp must have signature (x, dx, res: var Y)", jvp)
+  var resType = params[3][1]
+  if resType.kind == nnkVarTy:
+    resType = resType[0]
+  resType
+
+# Checks adjoint identity <ybar, J dx> = <J^T ybar, dx>, with ybar generated internally.
+# Check: <ybar, J dx>  ==  <J^T ybar, dx>.
+proc runAdjointIdentity*(
+    cfg: TestConfig,
+    makeBase: auto,
+    makeDir: auto,
+    jvp: auto,
+    vjp: auto
+  ): TestResult =
+  type X = typeof(makeBase(0))
+  type DX = typeof(makeDir(0, default(X)))
+  type Y = jvpResType(jvp)
+  proc makeYbar(sample: int; base: X): Y =
+    let s1 = sample + cfg.samples + 1
+    let s2 = sample + cfg.samples + 2
+    when compiles(result = makeDir(s1, base)):
+      result = makeDir(s1, base)
+    elif compiles(result = makePair(makeDir(s1, base), makeDir(s2, base))):
+      result = makePair(makeDir(s1, base), makeDir(s2, base))
+    else:
+      let dx2 = makeDir(s1, base)
+      result = seedFromDir[Y, DX](dx2)
+      jvp(base, dx2, result)
+  reportBanner(cfg)
+  result.name = cfg.name
+  for sample in 0..<cfg.samples:
+    let base = makeBase(sample)
+    let dx = makeDir(sample, base)
+    var dy = seedFromDir[Y, DX](dx)
+    let ybar = makeYbar(sample, base)
+    var dxbar = allocLike(dx)
+    jvp(base, dx, dy)
+    vjp(base, ybar, dxbar)
+    let lhs = dotLike(ybar, dy)
+    let rhs = dotLike(dxbar, dx)
+    let err = abs(lhs - rhs)
+    let refVal = max(1.0, max(abs(lhs), abs(rhs)))
+    let rel = err / refVal
+    let ok = err <= max(cfg.atol, cfg.rtol * refVal)
+    reportSimple(cfg, sample, lhs, rhs, err, rel, ok)
+    if ok: inc result.passed else: inc result.failed
+
+# Checks linearity: A(a v1 + b v2) == a A(v1) + b A(v2).
+# Check: A(a v1 + b v2)  ==  a A(v1) + b A(v2).
+proc runLinearity*(
+    cfg: TestConfig,
+    makeVec: auto,
+    makeProbe: auto,
+    combine: auto,
+    apply: auto,
+    a: float = 0.7,
+    b: float = -1.3
+  ): TestResult =
+  reportBanner(cfg)
+  result.name = cfg.name
+  for sample in 0..<cfg.samples:
+    let v1 = makeVec(sample)
+    let v2 = makeVec(sample)
+    let probe = makeProbe(sample)
+    var v12 = allocLike(v1)
+    combine(v1, v2, a, b, v12)
+    var y1 = allocLike(probe)
+    var y2 = allocLike(probe)
+    var y12 = allocLike(probe)
+    apply(v1, y1)
+    apply(v2, y2)
+    apply(v12, y12)
+    let lhs = dotLike(probe, y12)
+    let rhs = a * dotLike(probe, y1) + b * dotLike(probe, y2)
+    let err = abs(lhs - rhs)
+    let refVal = max(1.0, max(abs(lhs), abs(rhs)))
+    let rel = err / refVal
+    let ok = err <= max(cfg.atol, cfg.rtol * refVal)
+    reportSimple(cfg, sample, lhs, rhs, err, rel, ok)
+    if ok: inc result.passed else: inc result.failed
+
+# Runs a sweep over coefficient cases and aggregates pass/fail.
+# Check: passed = sum_i passed_i, failed = sum_i failed_i.
+proc runCoefSweep*[T](
+    name: string;
+    coefs: openArray[T];
+    labels: openArray[string];
+    runOne: proc(coef: T): TestResult
+  ): TestResult =
+  reportBanner(name)
+  result.name = name
+  var passedCombos: seq[int] = @[]
+  var failedCombos: seq[int] = @[]
+  for idx in 0..<coefs.len:
+    let res = runOne(coefs[idx])
+    result.add(res)
+    let status = if res.failed == 0: "PASS" else: "FAIL"
+    if idx < labels.len:
+      echo "Combo ", idx, " ", labels[idx], ": ", status
+    else:
+      echo "Combo ", idx, ": ", status
+    if res.failed == 0:
+      passedCombos.add(idx)
+    else:
+      failedCombos.add(idx)
+  echo ""
+  echo "Summary: Passed=", passedCombos, " Failed=", failedCombos
+  reportSummary(result)
+
+proc initGaugeTestEnv*(
+    defaultLat: seq[int] = @[8,8,8,8],
+    defaultSeed: uint64 = 4321'u64,
+    randomize = true,
+    preSmear = true,
+    preSmearSteps = 10,
+    preSmearAlpha = 0.1
+  ): auto =
+  letParam:
+    gaugefile = ""
+    lat =
+      if fileExists(gaugefile):
+        getFileLattice gaugefile
+      else:
+        if gaugefile.len > 0:
+          qexWarn "Nonexistent gauge file: ", gaugefile
+        defaultLat
+    seed = defaultSeed
+  echoParams()
+  let lo = lat.newLayout
+  var g = lo.newGauge
+  let hasFile = gaugefile.len > 0 and fileExists(gaugefile)
+  if hasFile:
+    let status = g.loadGauge(gaugefile)
+    if status != 0:
+      qexWarn "Failed to load gauge file: ", gaugefile
+  elif randomize:
+    g.random
+    if preSmear and preSmearSteps > 0:
+      var ss = lo.newStoutSmear(preSmearAlpha)
+      for _ in 0..<preSmearSteps:
+        ss.smear(g, g)
+  g.echoPlaq
+  var r = newRNGField(MRG32k3a, lo, seed)
+  var env: GaugeTestEnv[type(lo), type(g), type(r)]
+  env.lo = lo
+  env.g = g
+  env.r = r
+  env.lat = lat
+  env.gaugefile = gaugefile
+  env.seed = seed
+  env.hasFile = hasFile
+  result = env
+
+proc newRandomTAHDir*[L, R](lo: L; r: var R): auto =
+  var p = lo.newGauge
+  p.randomTAH r
+  p
+
+
+proc addNoiseExp*[G](x: float; p: G; g: G; ng: G) =
+  qexGC()
+  threads:
+    for mu in 0..<g.len:
+      for e in g[mu]:
+        let t = x * p[mu][e]
+        ng[mu][e] := exp(t) * g[mu][e]
+  qexGC()
+
+proc addNoiseExpField*[F](x: float; p: F; g: F; ng: F) =
+  qexGC()
+  threads:
+    for i in g:
+      ng[i] := exp(x * p[i]) * g[i]
+  qexGC()
+
+proc scaleForceField*[G](a: var G; scale: float) =
+  ## Force fields live in the algebra but share the same container as gauge links.
+  if scale == 1.0 or a.len == 0:
+    return
+  let p = cast[ptr cArray[type(a[0])]](unsafeAddr(a[0]))
+  let len = a.len
+  threads:
+    for mu in 0..<len:
+      for e in p[mu]:
+        p[mu][e] *= scale
+
+proc acceptActionForceDefault*(
+    cfg: TestConfig;
+    ana, fd, err, fdErr, refVal: float;
+    sample: int
+  ): bool =
+  discard ana
+  discard fd
+  discard sample
+  acceptTol(cfg, err, fdErr, refVal)
+
+proc actionForceCfgDefault*(
+    name: string,
+    samples = defaultSamples,
+    eps = actionForceDefaultEps,
+    scale = defaultScale
+  ): TestConfig =
+  initTestConfig(
+    name = name,
+    samples = samples,
+    eps = eps,
+    scale = scale,
+    atol = actionForceDefaultAtol,
+    rtol = actionForceDefaultRtol,
+    fdFactor = actionForceDefaultFdFactor,
+    verbose = true
+  )
+
+# FD check for gauge action vs gauge force (VJP with scalar output).
+# Check: d/d eps S(g + eps*dg)|0  ==  <dg, force(g)> scaled by ybar.
+proc runGaugeActionForceFD*[L, G, R](
+    env: GaugeTestEnv[L, G, R],
+    action: proc(g: G): float,
+    deriv: proc(g: G; f: G),
+    cfg: TestConfig,
+    accept: AcceptFD = acceptActionForceDefault
+  ): TestResult =
+  type GaugeField = G
+  let lo = env.lo
+  let gptr = addr env.g
+  let rptr = addr env.r
+  var rng = initRand(env.seed.int)
+  reportBanner(cfg)
+  result.name = cfg.name
+  for sample in 0..<cfg.samples:
+    let base = gptr[]
+    let dx = newRandomTAHDir(lo, rptr[])
+    let ybar = 1.0 + 0.1 * (2.0 * rng.rand(1.0) - 1.0)
+    var xPert = allocLike(base)
+    var y: float
+    var dxbar = allocLike(dx)
+    proc F(eps: float): float =
+      addNoiseExp(eps, dx, base, xPert)
+      y = action(xPert)
+      dotLike(ybar, y)
+    var fd, fde: float
+    ndiff(fd, fde, F, 0.0, cfg.eps, scale = cfg.scale, ordMax = 6)
+    deriv(base, dxbar)
+    scaleForceField(dxbar, ybar)
+    let ana = dotLike(dxbar, dx)
+    let err = abs(ana - fd)
+    let refVal = max(1.0, abs(fd))
+    let ok = if accept != nil:
+      accept(cfg, ana, fd, err, fde, refVal, sample)
+    else:
+      acceptTol(cfg, err, fde, refVal)
+    reportFD(cfg, sample, ana, fd, err, fde, ok)
+    if ok: inc result.passed else: inc result.failed
+
+# FD check for gauge HVP using a gradient and hvp callback.
+# Check: d/d eps <p, grad(g + eps*dg)>|0  ==  <p, H dg>.
+proc runGaugeHVPFD*[L, G, R](
+    env: var GaugeTestEnv[L, G, R],
+    grad: proc(x: G; res: var G),
+    hvp: proc(x: G; dx: G; res: var G),
+    cfg: TestConfig,
+    makeProbe: proc(sample: int; x: G; dx: G): G = nil
+  ): TestResult =
+  type GaugeField = G
+  let lo = env.lo
+  let gptr = addr env.g
+  let rptr = addr env.r
+  var sharedDir: GaugeField
+  result = runFDJVP(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField = gptr[],
+    makeDir = proc(sample: int; x: GaugeField): GaugeField =
+      sharedDir = newRandomTAHDir(lo, rptr[])
+      sharedDir,
+    makeProbe = proc(sample: int; x: GaugeField): GaugeField =
+      if makeProbe != nil:
+        makeProbe(sample, x, sharedDir)
+      else:
+        sharedDir,
+    perturb = proc(x: GaugeField; dx: GaugeField; eps: float; res: var GaugeField) =
+      addNoiseExp(eps, dx, x, res),
+    f = grad,
+    jvp = hvp,
+    ordMax = 6
+  )
+
+# FD check for gauge JVP with field-valued outputs.
+# Check: d/d eps <p, f(g + eps*dg)>|0  ==  <p, J dg>.
+proc runGaugeJVPFD*[L, G, R](
+    env: var GaugeTestEnv[L, G, R],
+    f: proc(x: G; res: var G),
+    jvp: proc(x: G; dx: G; res: var G),
+    cfg: TestConfig,
+    makeProbe: proc(sample: int; x: G): G = nil,
+    makeDir: proc(sample: int; x: G): G = nil,
+    perturb: proc(x: G; dx: G; eps: float; res: var G) = nil
+  ): TestResult =
+  type GaugeField = G
+  let lo = env.lo
+  let gptr = addr env.g
+  let rptr = addr env.r
+  var sharedDir: GaugeField
+  proc dirProc(sample: int; x: GaugeField): GaugeField =
+    if makeDir != nil:
+      sharedDir = makeDir(sample, x)
+    else:
+      sharedDir = newRandomTAHDir(lo, rptr[])
+    sharedDir
+  proc probeProc(sample: int; x: GaugeField): GaugeField =
+    if makeProbe != nil:
+      makeProbe(sample, x)
+    else:
+      sharedDir
+  proc perturbProc(x: GaugeField; dx: GaugeField; eps: float; res: var GaugeField) =
+    if perturb != nil:
+      perturb(x, dx, eps, res)
+    else:
+      addNoiseExp(eps, dx, x, res)
+  result = runFDJVP(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField = gptr[],
+    makeDir = dirProc,
+    makeProbe = probeProc,
+    perturb = perturbProc,
+    f = f,
+    jvp = jvp,
+    ordMax = 6
+  )
+
+# Adjoint identity check specialized to gauge fields.
+# Check: <ybar, J dg>  ==  <J^T ybar, dg>.
+proc runGaugeAdjointIdentity*[L, G, R](
+    env: var GaugeTestEnv[L, G, R],
+    jvp: proc(x: G; dx: G; res: var G),
+    vjp: proc(x: G; ybar: G; res: var G),
+    cfg: TestConfig,
+    makeDir: proc(sample: int; x: G): G = nil
+  ): TestResult =
+  type GaugeField = G
+  let lo = env.lo
+  let gptr = addr env.g
+  let rptr = addr env.r
+  proc dirProc(sample: int; x: GaugeField): GaugeField =
+    if makeDir != nil:
+      makeDir(sample, x)
+    else:
+      newRandomTAHDir(lo, rptr[])
+  result = runAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField = gptr[],
+    makeDir = dirProc,
+    jvp = jvp,
+    vjp = vjp
+  )

From 98100645dc0ed2d93ad12daa196f27ed00becbd9 Mon Sep 17 00:00:00 2001
From: Xiao-Yong Jin <xjin@anl.gov>
Date: Thu, 12 Mar 2026 11:45:50 -0500
Subject: [PATCH 2/7] gauge/hypsmear: refactor, restore closure force code

---
 src/gauge/hypsmear.nim | 727 +++++++++++++++++++++++++++--------------
 tests/deriv/thyp.nim   | 374 ++++++++++++++++++++-
 tests/deriv/utils.nim  |  31 +-
 3 files changed, 882 insertions(+), 250 deletions(-)

diff --git a/src/gauge/hypsmear.nim b/src/gauge/hypsmear.nim
index b4bb6dbd..63932245 100644
--- a/src/gauge/hypsmear.nim
+++ b/src/gauge/hypsmear.nim
@@ -139,12 +139,210 @@ proc smearGetForce*[G](coef: HypCoefs, gf: G, fl: G,
   ## Note that the resulting proc, smearedForce, holds a reference to the input gauge gf.
   ## The correctness of the algorithm depends on gf remaining the same.
   ## On the contrary, any changes to the smeared gauge fl would have no effects to the force calculation.
+  tic()
+  type lcm = type(gf[0])
   let lo = gf[0].l
-  var hs = lo.newHypSmear(coef)
-  hs.smear(gf, fl)
-  discard info
-  proc smearedForce(f, chain: G) =
-    hs.smearVJP(f, chain)
+  proc newlcm: lcm = result.new(gf[0].l)
+  var
+    l1x = newFieldArray2(lo,lcm,[4,4],mu!=nu)
+    l2x = newOneOf(l1x)
+    flx = newFieldArray(lo,lcm,4)
+    tm1: lcm
+    sm1: array[4,Shifter[lcm,type(gf[0][0])]]
+    s1: array[4,array[4,Shifter[lcm,type(gf[0][0])]]]
+    #nflop = 61632.0
+    #dtime = 0.0
+  when keepProj:
+    var
+      l1 = newOneOf(l1x)
+      l2 = newOneOf(l1x)
+  else:
+    var
+      lp1 = newlcm()
+      lp2 = newlcm()
+
+  tm1 = newlcm()
+  for mu in 0..<4:
+    sm1[mu] = newShifter(gf[mu], mu, -1)
+    for nu in 0..<4:
+      if nu!=mu:
+        s1[mu][nu] = newShifter(gf[mu], nu, 1)
+  threads:
+    for mu in 0..<4:
+      for nu in 0..<4:
+        if nu!=mu:
+          discard s1[mu][nu] ^*! gf[mu]
+
+  let
+    alp1 = coef.alpha1 / 2.0
+    alp2 = coef.alpha2 / 4.0
+    alp3 = coef.alpha3 / 6.0
+    ma1 = 1 - coef.alpha1
+    ma2 = 1 - coef.alpha2
+    ma3 = 1 - coef.alpha3
+
+  toc("prep")
+  threads:
+    for mu in 0..<4:
+      for nu in 0..<4:
+        if nu!=mu:
+          l1x[mu,nu] := ma1 * gf[mu]
+          symStaple(l1x[mu,nu], alp1, gf[nu], gf[mu],
+                    s1[nu][mu], s1[mu][nu], tm1, sm1[nu])
+          when keepProj:
+            l1[mu,nu].proj l1x[mu,nu]
+    toc("1")
+
+    for mu in 0..<4:
+      for nu in 0..<4:
+        if nu!=mu:
+          l2x[mu,nu] := ma2 * gf[mu]
+          for a in 0..<4:
+            if a!=mu and a!=nu:
+              let b = 1+2+3-mu-nu-a
+              when keepProj:
+                template lp1:untyped = l1[a,b]
+                template lp2:untyped = l1[mu,b]
+              else:
+                lp1.proj l1x[a,b]
+                lp2.proj l1x[mu,b]
+              threadBarrier()
+              discard s1[nu][mu] ^*! lp1
+              discard s1[mu][a] ^*! lp2
+              threadBarrier()
+              symStaple(l2x[mu,nu], alp2, lp1, lp2,
+                        s1[nu][mu], s1[mu][a], tm1, sm1[a])
+          when keepProj:
+            l2[mu,nu].proj l2x[mu,nu]
+    toc("2")
+
+    for mu in 0..<4:
+      flx[mu] := ma3 * gf[mu]
+      for nu in 0..<4:
+        if nu!=mu:
+          when keepProj:
+            template lp1:untyped = l2[nu,mu]
+            template lp2:untyped = l2[mu,nu]
+          else:
+            lp1.proj l2x[nu,mu]
+            lp2.proj l2x[mu,nu]
+          threadBarrier()
+          discard s1[nu][mu] ^*! lp1
+          discard s1[mu][nu] ^*! lp2
+          threadBarrier()
+          symStaple(flx[mu], alp3, lp1, lp2,
+                    s1[nu][mu], s1[mu][nu], tm1, sm1[nu])
+      fl[mu].proj flx[mu]
+  toc("threads end")
+
+  proc smearedForce(f,chain:G) =
+    tic("smearedF")
+    # fₓₚₜ ← chainₘₖₕ d/dUₓₚₜ^*[Vₘₖₕ(U)^*] + chainₘₕₖ^* d/dUₓₚₜ^*[Vₘₕₖ(U)]
+    var
+      fl1 = newFieldArray2(lo,lcm,[4,4],mu!=nu)
+      fl2 = newOneOf(fl1)
+      fc = newFieldArray(lo,lcm,4)
+      fs: array[4,Shifter[lcm,type(gf[0][0])]]
+      tm2: lcm
+    tm2 = newlcm()
+    for mu in 0..<4:
+      fs[mu] = newShifter(fc[mu], mu, 1)
+    toc("prep")
+
+    threads:
+      for mu in 0..<4:
+        for nu in 0..<4:
+          if nu!=mu:
+            fl1[mu,nu] := 0
+            fl2[mu,nu] := 0
+
+      # proj flx → fl, fc ← chain
+      for mu in 0..<4:
+        fc[mu].projDeriv(flx[mu], chain[mu])
+      # link (gf, l2) → flx, (f, fl2) ← fc
+      for mu in 0..<4:
+        f[mu] := ma3 * fc[mu]
+        fc[mu] *= alp3
+      for mu in 0..<4:
+        for nu in 0..<4:
+          if nu!=mu:
+            when keepProj:
+              template lp1:untyped = l2[nu,mu]
+              template lp2:untyped = l2[mu,nu]
+            else:
+              lp1.proj l2x[nu,mu]
+              lp2.proj l2x[mu,nu]
+            threadBarrier()
+            discard s1[nu][mu] ^*! lp1
+            discard s1[mu][nu] ^*! lp2
+            discard fs[nu] ^*! fc[mu]
+            threadBarrier()
+            symStapleDeriv(fl2[nu,mu], fl2[mu,nu],
+                           lp1, lp2, s1[nu][mu], s1[mu][nu],
+                           fc[mu], fs[nu], tm1, tm2, sm1[nu], sm1[mu])
+      toc("1")
+
+      # proj l2x → l2, fl2 ← fl2
+      for mu in 0..<4:
+        for nu in 0..<4:
+          if nu!=mu:
+            when keepProj:
+              fl2[mu,nu].projDeriv(l2[mu,nu], l2x[mu,nu], fl2[mu,nu])
+            else:
+              fl2[mu,nu].projDeriv(l2x[mu,nu], fl2[mu,nu])
+      # link (gf, l1) → l2x, (f, fl1) ← fl2
+      for mu in 0..<4:
+        for nu in 0..<4:
+          if nu!=mu:
+            f[mu] += ma2 * fl2[mu,nu]
+            fl2[mu,nu] *= alp2
+      for mu in 0..<4:
+        for nu in 0..<4:
+          if nu!=mu:
+            for a in 0..<4:
+              if a!=mu and a!=nu:
+                let b = 1+2+3-mu-nu-a
+                when keepProj:
+                  template lp1:untyped = l1[a,b]
+                  template lp2:untyped = l1[mu,b]
+                else:
+                  lp1.proj l1x[a,b]
+                  lp2.proj l1x[mu,b]
+                threadBarrier()
+                discard s1[nu][mu] ^*! lp1
+                discard s1[mu][a] ^*! lp2
+                discard fs[a] ^*! fl2[mu,nu]
+                threadBarrier()
+                symStapleDeriv(fl1[a,b], fl1[mu,b],
+                               lp1, lp2, s1[nu][mu], s1[mu][a],
+                               fl2[mu,nu], fs[a], tm1, tm2, sm1[a], sm1[mu])
+      toc("2")
+
+      # proj l1x → l1, fl1 ← fl1
+      for mu in 0..<4:
+        for nu in 0..<4:
+          if nu!=mu:
+            when keepProj:
+              fl1[mu,nu].projDeriv(l1[mu,nu], l1x[mu,nu], fl1[mu,nu])
+            else:
+              fl1[mu,nu].projDeriv(l1x[mu,nu], fl1[mu,nu])
+            discard s1[mu][nu] ^*! gf[mu]
+      # link gf → l1, f ← fl1
+      for mu in 0..<4:
+        for nu in 0..<4:
+          if nu!=mu:
+            f[mu] += ma1 * fl1[mu,nu]
+            fl1[mu,nu] *= alp1
+      for mu in 0..<4:
+        for nu in 0..<4:
+          if nu!=mu:
+            discard fs[nu] ^* fl1[mu,nu]
+            symStapleDeriv(f[nu], f[mu],
+                           gf[nu], gf[mu], s1[nu][mu], s1[mu][nu],
+                           fl1[mu,nu], fs[nu], tm1, tm2, sm1[nu], sm1[mu])
+    toc("end")
+
+  toc("end")
   smearedForce
 
 proc smearPriv[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) {.codegenDecl:
@@ -153,10 +351,8 @@ proc smearPriv[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) {.codegenDec
   # in order to guarantee the change of the stack pointer,
   # such that Nim's GC is able to collect the memory.
   {.emit: "asm (\"\");".}
-  let lo = gf[0].l
-  var hs = lo.newHypSmear(coef)
-  hs.smear(gf, fl)
-  discard info
+  var f = coef.smearGetForce(gf, fl, info)
+  f = nil
 proc smear*[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) =
   ## Try our best to release memory here.
   ## Sometimes it still requires a GC after this function returns.
@@ -177,7 +373,7 @@ proc smear*(c: HypCoefs, g: auto, fl: auto) =
 
 # Preallocated HYP smearing environment, following stoutsmear style
 type
-  HypForwardState[L,F,T] = object
+  HypForwardState[V:static[int],F,T] = object
     ## Persistent state produced by `smear` and consumed by derivative passes.
     gf*: array[4,F]
     ## Dedicated shifters for pair terms built directly from the original gauge
@@ -189,20 +385,20 @@ type
     ## between gauge and projected-link phases.
     stagePairShift*: array[4,array[4,Shifter[F,T]]]
     sm1*: array[4,Shifter[F,T]]
-    l1x*, l2x*: FieldArray[2,L.V,T]
+    l1x*, l2x*: FieldArray[2,V,T]
     when keepProj:
-      l1*, l2*: FieldArray[2,L.V,T]
-    flx*: FieldArray[1,L.V,T]
+      l1*, l2*: FieldArray[2,V,T]
+    flx*: FieldArray[1,V,T]
 
-  HypScratch[L,F,T] = object
+  HypScratch[V:static[int],F,T] = object
     ## Mutable work buffers used by reverse/tangent passes.
     ## Post-projection chain values for the output, Level 1, and Level 2
     ## reverse passes. These are scratch, not cached forward state.
-    outputChain*: FieldArray[1,L.V,T]
-    level1Chain*, level2Chain*: FieldArray[2,L.V,T]
+    outputChain*: FieldArray[1,V,T]
+    level1Chain*, level2Chain*: FieldArray[2,V,T]
     ## Pre-projection chain values saved specifically for second-order
     ## projection adjoints.
-    preProjLevel1Chain*, preProjLevel2Chain*: FieldArray[2,L.V,T]
+    preProjLevel1Chain*, preProjLevel2Chain*: FieldArray[2,V,T]
     ## Reusable forward shifters indexed by direction. `chainShift` is used for
     ## active chain fields, while `seedShift` stays available as a second
     ## scratch pool when the higher-order adjoints need an extra shifted seed.
@@ -210,15 +406,15 @@ type
     seedShift*: array[4,Shifter[F,T]]
     tm1*, tm2*: F
 
-  HypSmear*[L,F,T] = object
+  HypSmear*[V:static[int],F,T] = object
     ## Reusable buffers for HYP smearing and its derivative.
     ##
     ## The forward state is intentionally separated from the mutable scratch so
     ## it is clear which fields are part of the cached smear result and which
     ## are transient workspaces for reverse/tangent evaluations.
     coef*: HypCoefs
-    state*: HypForwardState[L,F,T]
-    work*: HypScratch[L,F,T]
+    state*: HypForwardState[V,F,T]
+    work*: HypScratch[V,F,T]
 
   HypTangentState[GaugeTangent, OutputTangent, PairField, PairShift] = object
     dgEff*: GaugeTangent
@@ -250,7 +446,7 @@ type
   HypLevel3AdjointScratch[GaugeField] = object
     dcbar*: GaugeField
 
-proc scaleFactors[L,F,T](hs: HypSmear[L,F,T]): HypScaleFactors {.inline.} =
+proc scaleFactors[V:static[int],F,T](hs: HypSmear[V,F,T]): HypScaleFactors {.inline.} =
   result = HypScaleFactors(
     alp1: hs.coef.alpha1 / 2.0,
     alp2: hs.coef.alpha2 / 4.0,
@@ -260,12 +456,23 @@ proc scaleFactors[L,F,T](hs: HypSmear[L,F,T]): HypScaleFactors {.inline.} =
     ma3: 1 - hs.coef.alpha3,
   )
 
+proc pairStageScales[Stage: static int](hs: HypSmear): auto {.inline.} =
+  let sc = hs.scaleFactors
+  when Stage == 1:
+    result = (ma: sc.ma1, alp: sc.alp1)
+  else:
+    result = (ma: sc.ma2, alp: sc.alp2)
+
+proc outputStageScales(hs: HypSmear): auto {.inline.} =
+  let sc = hs.scaleFactors
+  result = (ma: sc.ma3, alp: sc.alp3)
+
 proc newHypSmear*(l: Layout, coef: HypCoefs): auto =
   ## Allocate a reusable environment for HYP smearing and derivatives
   type F = type(l.newGauge[0])
   type T = type(l.newGauge[0][0])
   type L = type(l)
-  var hs: HypSmear[L,F,T]
+  var hs: HypSmear[L.V,F,T]
   hs.coef = coef
   hs.state.l1x = newFieldArray2(l,F,[4,4],mu!=nu)
   hs.state.l2x = newFieldArray2(l,F,[4,4],mu!=nu)
@@ -292,19 +499,20 @@ proc newHypSmear*(l: Layout, coef: HypCoefs): auto =
 
 proc initProjectedLevelsImpl(hs: var HypSmear; l1, l2: var auto;
                              populateFromCache: static bool) =
+  let hsp = hs.addr
   when keepProj:
-    l1 = hs.state.l1
-    l2 = hs.state.l2
+    l1 = hsp[].state.l1
+    l2 = hsp[].state.l2
   else:
-    let lo = hs.state.gf[0].l
-    type Fld = typeof(hs.state.gf[0])
+    let lo = hsp[].state.gf[0].l
+    type Fld = typeof(hsp[].state.gf[0])
     l1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
     l2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
     when populateFromCache:
       threads:
         forPairs(mu, nu):
-          l1[mu,nu].proj hs.state.l1x[mu,nu]
-          l2[mu,nu].proj hs.state.l2x[mu,nu]
+          l1[mu,nu].proj hsp[].state.l1x[mu,nu]
+          l2[mu,nu].proj hsp[].state.l2x[mu,nu]
 
 proc initProjectedLevels(hs: var HypSmear; l1, l2: var auto) =
   initProjectedLevelsImpl(hs, l1, l2, true)
@@ -497,65 +705,85 @@ template forLevel3Pairs(hs, l2, pl1, pl2: untyped; body: untyped) =
       let pl2 = l2[mu,nu]
       body
 
-template buildLevel3ReverseChains(hs, l2, outputChain, level2Chain, tm1, tm2: auto) =
-  forLevel3Pairs(hs, l2, pl1, pl2):
+proc hypOutputStageStapleVJP*(hs: var HypSmear, l2, outputChain: auto;
+                              level2Chain: auto) =
+  let hsp = hs.addr
+  forLevel3Pairs(hsp[], l2, pl1, pl2):
     threadBarrier()
-    discard hs.work.chainShift[nu] ^*! outputChain[mu]
+    discard hsp[].work.chainShift[nu] ^*! outputChain[mu]
     threadBarrier()
     symStapleVJP(level2Chain[nu,mu], level2Chain[mu,nu],
                  pl1, pl2,
-                 hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][nu],
-                 outputChain[mu], hs.work.chainShift[nu],
-                 tm1, tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+                 hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
+                 outputChain[mu], hsp[].work.chainShift[nu],
+                 hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+    threadBarrier()
+
+proc hypOutputStageChainVJP*(hs: var HypSmear, l2, seedBar: auto;
+                             outputChainBar: auto) =
+  let hsp = hs.addr
+  forLevel3Pairs(hsp[], l2, pl1, pl2):
+    symStapleVJPChain(outputChainBar[mu],
+                      pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
+                      seedBar[nu,mu], seedBar[mu,nu],
+                      hsp[].work.chainShift[nu], hsp[].work.seedShift[mu],
+                      hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu])
     threadBarrier()
 
-template buildForwardPairStage(Stage: static int, hs, pairSrc, outX, outProj,
-                               ma, alp, tm1: untyped) =
+## Pair-stage operator family.
+## Stage 1 corresponds to L1; Stage 2 corresponds to L2.
+proc hypPairStage*[Stage: static int](hs: var HypSmear, pairSrc: auto;
+                                      outX, outProj: auto) =
+  let hsp = hs.addr
+  let sc = pairStageScales[Stage](hsp[])
   when Stage == 1:
     threads:
       forPairs(mu, nu):
-        discard hs.state.gaugePairShift[mu][nu] ^*! hs.state.gf[mu]
+        discard hsp[].state.gaugePairShift[mu][nu] ^*! hsp[].state.gf[mu]
 
   threads:
     forPairs(mu, nu):
-      outX[mu,nu] := ma * hs.state.gf[mu]
+      outX[mu,nu] := sc.ma * hsp[].state.gf[mu]
       when Stage == 1:
-        symStaple(outX[mu,nu], alp, hs.state.gf[nu], hs.state.gf[mu],
-                  hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
-                  tm1, hs.state.sm1[nu])
+        symStaple(outX[mu,nu], sc.alp, hsp[].state.gf[nu], hsp[].state.gf[mu],
+                  hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                  hsp[].work.tm1, hsp[].state.sm1[nu])
         threadBarrier()
       else:
         forThird(mu, nu, a, b):
           let pl1 = pairSrc[a,b]
           let pl2 = pairSrc[mu,b]
           threadBarrier()
-          discard hs.state.stagePairShift[nu][mu] ^*! pl1
-          discard hs.state.stagePairShift[mu][a] ^*! pl2
+          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
           threadBarrier()
-          symStaple(outX[mu,nu], alp, pl1, pl2,
-                    hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
-                    tm1, hs.state.sm1[a])
+          symStaple(outX[mu,nu], sc.alp, pl1, pl2,
+                    hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                    hsp[].work.tm1, hsp[].state.sm1[a])
           threadBarrier()
       outProj[mu,nu].proj outX[mu,nu]
 
-template buildTangentPairStage(Stage: static int, hs, pairSrc, tangentSrc,
-                               shiftedTangents, preProjOut, tangentOut,
-                               preProjBase, projBase, dgEff, ma, alp, tm1: untyped) =
+proc hypPairStageJVP*[Stage: static int](hs: var HypSmear, pairSrc, tangentSrc,
+                                         shiftedTangents, preProjBase, projBase,
+                                         dgEff: auto;
+                                         preProjOut, tangentOut: auto) =
+  let hsp = hs.addr
+  let sc = pairStageScales[Stage](hsp[])
   when Stage == 1:
     threads:
       forPairs(mu, nu):
-        discard hs.state.gaugePairShift[mu][nu] ^*! hs.state.gf[mu]
+        discard hsp[].state.gaugePairShift[mu][nu] ^*! hsp[].state.gf[mu]
 
   threads:
     forPairs(mu, nu):
-      preProjOut[mu,nu] := ma * dgEff[mu]
+      preProjOut[mu,nu] := sc.ma * dgEff[mu]
       when Stage == 1:
-        symStapleJVP(preProjOut[mu,nu], alp,
-                     hs.state.gf[nu], hs.state.gf[mu],
-                     hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
+        symStapleJVP(preProjOut[mu,nu], sc.alp,
+                     hsp[].state.gf[nu], hsp[].state.gf[mu],
+                     hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
                      tangentSrc[nu], tangentSrc[mu],
                      shiftedTangents[nu][mu], shiftedTangents[mu][nu],
-                     tm1, hs.state.sm1[nu])
+                     hsp[].work.tm1, hsp[].state.sm1[nu])
         threadBarrier()
       else:
         forThird(mu, nu, a, b):
@@ -564,73 +792,75 @@ template buildTangentPairStage(Stage: static int, hs, pairSrc, tangentSrc,
           let dpl1 = tangentSrc[a,b]
           let dpl2 = tangentSrc[mu,b]
           threadBarrier()
-          discard hs.state.stagePairShift[nu][mu] ^*! pl1
-          discard hs.state.stagePairShift[mu][a] ^*! pl2
+          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
           discard shiftedTangents[mu][nu][a][0] ^*! dpl1
           discard shiftedTangents[mu][nu][a][1] ^*! dpl2
           threadBarrier()
-          symStapleJVP(preProjOut[mu,nu], alp,
-                       pl1, pl2, hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
+          symStapleJVP(preProjOut[mu,nu], sc.alp,
+                       pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
                        dpl1, dpl2,
                        shiftedTangents[mu][nu][a][0], shiftedTangents[mu][nu][a][1],
-                       tm1, hs.state.sm1[a])
+                       hsp[].work.tm1, hsp[].state.sm1[a])
           threadBarrier()
       tangentOut[mu,nu].projJVP(projBase[mu,nu], preProjBase[mu,nu], preProjOut[mu,nu])
 
-template applyReversePairStage(Stage: static int, hs, pairSrc, chainIn, dst,
-                               tm1, tm2: untyped) =
+proc hypPairStageStapleVJP*[Stage: static int](hs: var HypSmear, pairSrc, chainIn: auto;
+                                               dst: auto) =
+  let hsp = hs.addr
   threads:
     forPairs(mu, nu):
       when Stage == 1:
-        discard hs.work.chainShift[nu] ^* chainIn[mu,nu]
+        discard hsp[].work.chainShift[nu] ^* chainIn[mu,nu]
         symStapleVJP(dst[nu], dst[mu],
-                     hs.state.gf[nu], hs.state.gf[mu],
-                     hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
-                     chainIn[mu,nu], hs.work.chainShift[nu],
-                     tm1, tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+                     hsp[].state.gf[nu], hsp[].state.gf[mu],
+                     hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                     chainIn[mu,nu], hsp[].work.chainShift[nu],
+                     hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
         threadBarrier()
       else:
         forThird(mu, nu, a, b):
           let pl1 = pairSrc[a,b]
           let pl2 = pairSrc[mu,b]
           threadBarrier()
-          discard hs.state.stagePairShift[nu][mu] ^*! pl1
-          discard hs.state.stagePairShift[mu][a] ^*! pl2
-          discard hs.work.chainShift[a] ^*! chainIn[mu,nu]
+          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+          discard hsp[].work.chainShift[a] ^*! chainIn[mu,nu]
           threadBarrier()
           symStapleVJP(dst[a,b], dst[mu,b],
                        pl1, pl2,
-                       hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
-                       chainIn[mu,nu], hs.work.chainShift[a],
-                       tm1, tm2, hs.state.sm1[a], hs.state.sm1[mu])
+                       hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                       chainIn[mu,nu], hsp[].work.chainShift[a],
+                       hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
           threadBarrier()
 
-template applyReversePairStageChainAdjoint(Stage: static int, hs, pairSrc,
-                                           dst, seedBar, tm1, tm2: untyped) =
+proc hypPairStageChainVJP*[Stage: static int](hs: var HypSmear, pairSrc, seedBar: auto;
+                                              dst: auto) =
+  let hsp = hs.addr
   threads:
     forPairs(mu, nu):
       when Stage == 1:
         symStapleVJPChain(dst[mu,nu],
-                          hs.state.gf[nu], hs.state.gf[mu],
-                          hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
+                          hsp[].state.gf[nu], hsp[].state.gf[mu],
+                          hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
                           seedBar[nu], seedBar[mu],
-                          hs.work.chainShift[nu], hs.work.seedShift[mu],
-                          tm1, tm2, hs.state.sm1[nu])
+                          hsp[].work.chainShift[nu], hsp[].work.seedShift[mu],
+                          hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu])
         threadBarrier()
       else:
         forThird(mu, nu, a, b):
           let pl1 = pairSrc[a,b]
           let pl2 = pairSrc[mu,b]
           threadBarrier()
-          discard hs.state.stagePairShift[nu][mu] ^*! pl1
-          discard hs.state.stagePairShift[mu][a] ^*! pl2
+          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
           threadBarrier()
           symStapleVJPChain(dst[mu,nu],
                             pl1, pl2,
-                            hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
+                            hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
                             seedBar[a,b], seedBar[mu,b],
-                            hs.work.chainShift[a], hs.work.seedShift[mu],
-                            tm1, tm2, hs.state.sm1[a])
+                            hsp[].work.chainShift[a], hsp[].work.seedShift[mu],
+                            hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a])
           threadBarrier()
 
 template accumulateAndScaleGauge(dst, src, ma, alp: auto) =
@@ -661,14 +891,16 @@ template applyPairProjectionHvpPhase(chainBar, dChainBar, projected, xfield,
   applyProjectionHVP(chainBar, dChainBar, projected, xfield, preProjChain, tangent)
   accumulateAndScalePairs(derivHvp, chainBar, ma, alp)
 
-template applyPairStapleHvpPhase(Stage: static int, hs, pairSrc, tangentSrc,
-                                 chainSrc, dChainIn, dst, tm1, tm2: untyped) =
+proc hypPairStageHVP*[Stage: static int](hs: var HypSmear, pairSrc, tangentSrc,
+                                         chainSrc, dChainIn: auto;
+                                         dst: auto) =
   block:
-    let lo = hs.state.gf[0].l
-    type Fld = typeof(hs.state.gf[0])
+    let hsp = hs.addr
+    let lo = hsp[].state.gf[0].l
+    type Fld = typeof(hsp[].state.gf[0])
     when Stage == 1:
-      var shiftedPairTangents: array[4, array[4, array[2, Shifter[Fld,type(hs.state.gf[0][0])]]]]
-      var shiftedChainTangents: array[4, array[4, Shifter[Fld,type(hs.state.gf[0][0])]]]
+      var shiftedPairTangents: array[4, array[4, array[2, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]
+      var shiftedChainTangents: array[4, array[4, Shifter[Fld,type(hsp[].state.gf[0][0])]]]
       forPairs(mu, nu):
         shiftedPairTangents[mu][nu][0] = newShifter(tangentSrc[nu], mu, 1)
         shiftedPairTangents[mu][nu][1] = newShifter(tangentSrc[mu], nu, 1)
@@ -678,22 +910,22 @@ template applyPairStapleHvpPhase(Stage: static int, hs, pairSrc, tangentSrc,
 
       threads:
         forPairs(mu, nu):
-          discard hs.work.chainShift[nu] ^* chainSrc[mu,nu]
+          discard hsp[].work.chainShift[nu] ^* chainSrc[mu,nu]
           discard shiftedPairTangents[mu][nu][0] ^*! tangentSrc[nu]
           discard shiftedPairTangents[mu][nu][1] ^*! tangentSrc[mu]
           discard shiftedChainTangents[mu][nu] ^*! dChainIn[mu,nu]
           symStapleHVP(dst[nu], dst[mu], acc1[mu,nu], acc2[mu,nu],
-                       hs.state.gf[nu], hs.state.gf[mu],
-                       hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
-                       chainSrc[mu,nu], hs.work.chainShift[nu],
+                       hsp[].state.gf[nu], hsp[].state.gf[mu],
+                       hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                       chainSrc[mu,nu], hsp[].work.chainShift[nu],
                        tangentSrc[nu], tangentSrc[mu], dChainIn[mu,nu],
                        shiftedPairTangents[mu][nu][0], shiftedPairTangents[mu][nu][1],
                        shiftedChainTangents[mu][nu],
-                       tm1, tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+                       hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
           threadBarrier()
     else:
-      var shiftedPairTangents: array[4, array[4, array[4, array[2, Shifter[Fld,type(hs.state.gf[0][0])]]]]]
-      var shiftedChainTangents: array[4, array[4, array[4, Shifter[Fld,type(hs.state.gf[0][0])]]]]
+      var shiftedPairTangents: array[4, array[4, array[4, array[2, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]]
+      var shiftedChainTangents: array[4, array[4, array[4, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]
       forPairs(mu, nu):
         forThird(mu, nu, a, b):
           shiftedPairTangents[mu][nu][a][0] = newShifter(tangentSrc[a,b], mu, 1)
@@ -703,8 +935,8 @@ template applyPairStapleHvpPhase(Stage: static int, hs, pairSrc, tangentSrc,
       var acc2: array[4, array[4, array[4, Fld]]]
       forPairs(mu, nu):
         forThird(mu, nu, a, b):
-          acc1[mu][nu][a] = lo.newField(type(hs.state.gf[0][0]))
-          acc2[mu][nu][a] = lo.newField(type(hs.state.gf[0][0]))
+          acc1[mu][nu][a] = lo.newField(type(hsp[].state.gf[0][0]))
+          acc2[mu][nu][a] = lo.newField(type(hsp[].state.gf[0][0]))
 
       threads:
         forPairs(mu, nu):
@@ -712,9 +944,9 @@ template applyPairStapleHvpPhase(Stage: static int, hs, pairSrc, tangentSrc,
             let pl1 = pairSrc[a,b]
             let pl2 = pairSrc[mu,b]
             threadBarrier()
-            discard hs.state.stagePairShift[nu][mu] ^*! pl1
-            discard hs.state.stagePairShift[mu][a] ^*! pl2
-            discard hs.work.chainShift[a] ^*! chainSrc[mu,nu]
+            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+            discard hsp[].work.chainShift[a] ^*! chainSrc[mu,nu]
             discard shiftedPairTangents[mu][nu][a][0] ^*! tangentSrc[a,b]
             discard shiftedPairTangents[mu][nu][a][1] ^*! tangentSrc[mu,b]
             discard shiftedChainTangents[mu][nu][a] ^*! dChainIn[mu,nu]
@@ -722,21 +954,22 @@ template applyPairStapleHvpPhase(Stage: static int, hs, pairSrc, tangentSrc,
             symStapleHVP(dst[a,b], dst[mu,b],
                          acc1[mu][nu][a], acc2[mu][nu][a],
                          pl1, pl2,
-                         hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
-                         chainSrc[mu,nu], hs.work.chainShift[a],
+                         hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                         chainSrc[mu,nu], hsp[].work.chainShift[a],
                          tangentSrc[a,b], tangentSrc[mu,b], dChainIn[mu,nu],
                          shiftedPairTangents[mu][nu][a][0], shiftedPairTangents[mu][nu][a][1],
                          shiftedChainTangents[mu][nu][a],
-                         tm1, tm2, hs.state.sm1[a], hs.state.sm1[mu])
+                         hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
             threadBarrier()
 
-template backpropPairHvpOutputPhase(Stage: static int, hs, pairSrc, chainSrc,
-                                    seedBar, pairBarOut, chainBar,
-                                    nextChainBar, projected, xfield,
-                                    preProjChain, alp, tm1, tm2: untyped) =
+proc hypPairStageHVPVJP*[Stage: static int](hs: var HypSmear, pairSrc, chainSrc,
+                                            seedBar, projected, xfield, preProjChain: auto;
+                                            pairBarOut, chainBar, nextChainBar: auto) =
   block:
-    let lo = hs.state.gf[0].l
-    type Fld = typeof(hs.state.gf[0])
+    let hsp = hs.addr
+    let sc = pairStageScales[Stage](hsp[])
+    let lo = hsp[].state.gf[0].l
+    type Fld = typeof(hsp[].state.gf[0])
     var dcbar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
     threads:
       forPairs(mu, nu):
@@ -745,34 +978,34 @@ template backpropPairHvpOutputPhase(Stage: static int, hs, pairSrc, chainSrc,
     threads:
       forPairs(mu, nu):
         when Stage == 1:
-          discard hs.work.chainShift[nu] ^* chainSrc[mu,nu]
+          discard hsp[].work.chainShift[nu] ^* chainSrc[mu,nu]
           symStapleHVPVJP(pairBarOut[nu], pairBarOut[mu], dcbar[mu,nu],
-                          hs.state.gf[nu], hs.state.gf[mu],
-                          hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
-                          chainSrc[mu,nu], hs.work.chainShift[nu],
+                          hsp[].state.gf[nu], hsp[].state.gf[mu],
+                          hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                          chainSrc[mu,nu], hsp[].work.chainShift[nu],
                           seedBar[nu], seedBar[mu],
-                          hs.work.seedShift[nu], hs.work.seedShift[mu],
-                          tm1, tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+                          hsp[].work.seedShift[nu], hsp[].work.seedShift[mu],
+                          hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
           threadBarrier()
         else:
           forThird(mu, nu, a, b):
             let pl1 = pairSrc[a,b]
             let pl2 = pairSrc[mu,b]
             threadBarrier()
-            discard hs.state.stagePairShift[nu][mu] ^*! pl1
-            discard hs.state.stagePairShift[mu][a] ^*! pl2
-            discard hs.work.chainShift[a] ^*! chainSrc[mu,nu]
+            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+            discard hsp[].work.chainShift[a] ^*! chainSrc[mu,nu]
             threadBarrier()
             symStapleHVPVJP(pairBarOut[a,b], pairBarOut[mu,b], dcbar[mu,nu],
                             pl1, pl2,
-                            hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
-                            chainSrc[mu,nu], hs.work.chainShift[a],
+                            hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                            chainSrc[mu,nu], hsp[].work.chainShift[a],
                             seedBar[a,b], seedBar[mu,b],
-                            hs.work.seedShift[a], hs.work.seedShift[mu],
-                            tm1, tm2, hs.state.sm1[a], hs.state.sm1[mu])
+                            hsp[].work.seedShift[a], hsp[].work.seedShift[mu],
+                            hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
             threadBarrier()
 
-    addScaledPairs(chainBar, dcbar, alp)
+    addScaledPairs(chainBar, dcbar, sc.alp)
 
     threads:
       forPairs(mu, nu):
@@ -781,43 +1014,84 @@ template backpropPairHvpOutputPhase(Stage: static int, hs, pairSrc, chainSrc,
           chainBar[mu,nu]
         )
 
-template backpropPairTangentPhase(Stage: static int, hs, pairSrc, tangentXBar,
-                                  pairBarOut, dgEffbar, ma, alp, tm1, tm2: untyped) =
+proc hypPairStageJVPVJP*[Stage: static int](hs: var HypSmear, pairSrc, tangentXBar: auto;
+                                            pairBarOut, dgEffbar: auto) =
+  let hsp = hs.addr
+  let sc = pairStageScales[Stage](hsp[])
   threads:
     forPairs(mu, nu):
-      dgEffbar[mu] += ma * tangentXBar[mu,nu]
+      dgEffbar[mu] += sc.ma * tangentXBar[mu,nu]
 
   threads:
     forPairs(mu, nu):
       when Stage == 1:
-        symStapleJVPVJP(dgEffbar[nu], dgEffbar[mu], alp,
-                        hs.state.gf[nu], hs.state.gf[mu],
-                        hs.state.gaugePairShift[nu][mu], hs.state.gaugePairShift[mu][nu],
-                        tangentXBar[mu,nu], hs.work.seedShift[nu],
-                        tm1, tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+        symStapleJVPVJP(dgEffbar[nu], dgEffbar[mu], sc.alp,
+                        hsp[].state.gf[nu], hsp[].state.gf[mu],
+                        hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                        tangentXBar[mu,nu], hsp[].work.seedShift[nu],
+                        hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
         threadBarrier()
       else:
         forThird(mu, nu, a, b):
           let pl1 = pairSrc[a,b]
           let pl2 = pairSrc[mu,b]
           threadBarrier()
-          discard hs.state.stagePairShift[nu][mu] ^*! pl1
-          discard hs.state.stagePairShift[mu][a] ^*! pl2
+          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
           threadBarrier()
-          symStapleJVPVJP(pairBarOut[a,b], pairBarOut[mu,b], alp,
+          symStapleJVPVJP(pairBarOut[a,b], pairBarOut[mu,b], sc.alp,
                           pl1, pl2,
-                          hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][a],
-                          tangentXBar[mu,nu], hs.work.seedShift[a],
-                          tm1, tm2, hs.state.sm1[a], hs.state.sm1[mu])
+                          hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                          tangentXBar[mu,nu], hsp[].work.seedShift[a],
+                          hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
           threadBarrier()
 
+## Final output-stage operator family built from L2 pair fields.
+proc hypOutputStage*(hs: var HypSmear, l2: auto; flx, fl: auto) =
+  let hsp = hs.addr
+  let sc = outputStageScales(hsp[])
+  threads:
+    forPairs(mu, nu):
+      discard hsp[].state.stagePairShift[mu][nu] ^*! l2[mu,nu]
+  threads:
+    for mu in 0..<4:
+      flx[mu] := sc.ma * hsp[].state.gf[mu]
+      forNu(mu, nu):
+        let pl1 = l2[nu,mu]
+        let pl2 = l2[mu,nu]
+        symStaple(flx[mu], sc.alp, pl1, pl2,
+                  hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
+                  hsp[].work.tm1, hsp[].state.sm1[nu])
+        threadBarrier()
+      fl[mu].proj flx[mu]
+
+proc hypOutputStageJVP*(hs: var HypSmear, l2, dl2, dsl2, dgEff: auto;
+                        dflx: auto) =
+  let hsp = hs.addr
+  let sc = outputStageScales(hsp[])
+  threads:
+    forPairs(mu, nu):
+      discard hsp[].state.stagePairShift[mu][nu] ^*! l2[mu,nu]
+
+  threads:
+    for mu in 0..<4:
+      dflx[mu] := sc.ma * dgEff[mu]
+      forNu(mu, nu):
+        let pl1 = l2[nu,mu]
+        let pl2 = l2[mu,nu]
+        let dpl1 = dl2[nu,mu]
+        let dpl2 = dl2[mu,nu]
+        symStapleJVP(dflx[mu], sc.alp,
+                     pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
+                     dpl1, dpl2, dsl2[nu][mu], dsl2[mu][nu],
+                     hsp[].work.tm1, hsp[].state.sm1[nu])
+        threadBarrier()
+
 proc buildTangentState[L,F,T](hs: var HypSmear[L,F,T], dg: auto): auto =
   ## Build the shared forward tangent state used by `smearJVP` and `smearHVP`.
-  let sc = hs.scaleFactors
   var l1: type(hs.state.l1x)
   var l2: type(hs.state.l2x)
   initProjectedLevels(hs, l1, l2)
-  let hsp = hs.addr
 
   let lo = hs.state.gf[0].l
   type Fld = typeof(hs.state.gf[0])
@@ -832,7 +1106,7 @@ proc buildTangentState[L,F,T](hs: var HypSmear[L,F,T], dg: auto): auto =
 
   clearTangentWorkspace(dflx, dl1x, dl2x, dl1, dl2)
 
-  buildTangentPairStage(1, hsp, l1, dgEff, ds1, dl1x, dl1, hsp.state.l1x, l1, dgEff, sc.ma1, sc.alp1, hsp.work.tm1)
+  hypPairStageJVP[1](hs, l1, dgEff, ds1, hs.state.l1x, l1, dgEff, dl1x, dl1)
 
   var dsl1_l2: array[4, array[4, array[4, array[2, Shifter[Fld,type(hs.state.gf[0][0])]]]]]
   forPairs(mu, nu):
@@ -840,7 +1114,7 @@ proc buildTangentState[L,F,T](hs: var HypSmear[L,F,T], dg: auto): auto =
       dsl1_l2[mu][nu][a][0] = newShifter(dl1[a,b], mu, 1)
       dsl1_l2[mu][nu][a][1] = newShifter(dl1[mu,b], a, 1)
 
-  buildTangentPairStage(2, hsp, l1, dl1, dsl1_l2, dl2x, dl2, hsp.state.l2x, l2, dgEff, sc.ma2, sc.alp2, hsp.work.tm1)
+  hypPairStageJVP[2](hs, l1, dl1, dsl1_l2, hs.state.l2x, l2, dgEff, dl2x, dl2)
 
   var dsl2: array[4,array[4,Shifter[Fld,type(hs.state.gf[0][0])]]]
   forPairs(mu, nu):
@@ -848,21 +1122,8 @@ proc buildTangentState[L,F,T](hs: var HypSmear[L,F,T], dg: auto): auto =
   threads:
     forPairs(mu, nu):
       discard dsl2[mu][nu] ^*! dl2[mu,nu]
-      discard hsp.state.stagePairShift[mu][nu] ^*! l2[mu,nu]
 
-  threads:
-    for mu in 0..<4:
-      dflx[mu] := sc.ma3 * dgEff[mu]
-      forNu(mu, nu):
-        let pl1 = l2[nu,mu]
-        let pl2 = l2[mu,nu]
-        let dpl1 = dl2[nu,mu]
-        let dpl2 = dl2[mu,nu]
-        symStapleJVP(dflx[mu], sc.alp3,
-                        pl1, pl2, hsp.state.stagePairShift[nu][mu], hsp.state.stagePairShift[mu][nu],
-                        dpl1, dpl2, dsl2[nu][mu], dsl2[mu][nu],
-                        hsp.work.tm1, hsp.state.sm1[nu])
-        threadBarrier()
+  hypOutputStageJVP(hs, l2, dl2, dsl2, dgEff, dflx)
 
   HypTangentState[typeof(dgEff), typeof(dflx), typeof(dl1x), typeof(dsl2)](
     dgEff: dgEff,
@@ -943,13 +1204,11 @@ template buildReverseState(hsp, chain, deriv: untyped; accumulateDirect: static
         deriv[mu] := sc.ma3 * hsp.work.outputChain[mu]
       hsp.work.outputChain[mu] *= sc.alp3
 
-  buildLevel3ReverseChains(hsp, l2, hsp.work.outputChain, hsp.work.level2Chain,
-                           hsp.work.tm1, hsp.work.tm2)
+  hypOutputStageStapleVJP(hsp[], l2, hsp[].work.outputChain, hsp[].work.level2Chain)
   projectAndScalePairChain(hsp.work.level2Chain, l2, hsp.state.l2x,
                            hsp.work.preProjLevel2Chain, sc.alp2, deriv, sc.ma2,
                            accumulateDirect)
-  applyReversePairStage(2, hsp, l1, hsp.work.level2Chain, hsp.work.level1Chain,
-                        hsp.work.tm1, hsp.work.tm2)
+  hypPairStageStapleVJP[2](hsp[], l1, hsp[].work.level2Chain, hsp[].work.level1Chain)
   projectAndScalePairChain(hsp.work.level1Chain, l1, hsp.state.l1x,
                            hsp.work.preProjLevel1Chain, sc.alp1, deriv, sc.ma1,
                            accumulateDirect)
@@ -957,36 +1216,19 @@ template buildReverseState(hsp, chain, deriv: untyped; accumulateDirect: static
 proc smear*(hs: var HypSmear, gf: auto, fl: auto) =
   static: doAssert(type(gf[0]) is typeof(hs.state.gf[0]))
   ## Apply HYP smearing; intermediates stored in hs for derivative
-  let sc = hs.scaleFactors
   for mu in 0..<4:
     hs.state.gf[mu] = gf[mu]
   var
-    cachedGauge = hs.state.gf
     l1x = hs.state.l1x
     l2x = hs.state.l2x
     flx = hs.state.flx
-    tm1 = hs.work.tm1
   var l1: typeof(l1x)
   var l2: typeof(l2x)
   initForwardProjectedLevels(hs, l1, l2)
-  let hsp = hs.addr
 
-  buildForwardPairStage(1, hsp, l1, l1x, l1, sc.ma1, sc.alp1, tm1)
-  buildForwardPairStage(2, hsp, l1, l2x, l2, sc.ma2, sc.alp2, tm1)
-  threads:
-    forPairs(mu, nu):
-      discard hsp.state.stagePairShift[mu][nu] ^*! l2[mu,nu]
-  threads:
-    for mu in 0..<4:
-      flx[mu] := sc.ma3 * cachedGauge[mu]
-      forNu(mu, nu):
-        let pl1 = l2[nu,mu]
-        let pl2 = l2[mu,nu]
-        symStaple(flx[mu], sc.alp3, pl1, pl2,
-                  hsp.state.stagePairShift[nu][mu], hsp.state.stagePairShift[mu][nu],
-                  tm1, hsp.state.sm1[nu])
-        threadBarrier()
-      fl[mu].proj flx[mu]
+  hypPairStage[1](hs, l1, l1x, l1)
+  hypPairStage[2](hs, l1, l2x, l2)
+  hypOutputStage(hs, l2, flx, fl)
 
 proc smearVJP*(hs: var HypSmear, deriv: auto, chain: auto) =
   static:
@@ -995,10 +1237,9 @@ proc smearVJP*(hs: var HypSmear, deriv: auto, chain: auto) =
   ## Backpropagate derivative through hs.smear
   let hsp = hs.addr
   buildReverseState(hsp, chain, deriv, true)
-  applyReversePairStage(1, hsp, hsp.work.level1Chain, hsp.work.level1Chain,
-                        deriv, hsp.work.tm1, hsp.work.tm2)
+  hypPairStageStapleVJP[1](hsp[], hsp[].work.level1Chain, hsp[].work.level1Chain, deriv)
 
-template applyOutputProjectionJvp(dst, projected, preProj, tangent: auto) =
+proc hypOutputProjectionJVP*(dst: auto; projected, preProj, tangent: auto) =
   let lo = preProj[0].l
   var tangentTmp = lo.newGauge
   threads:
@@ -1023,28 +1264,28 @@ proc smearJVP*[G](hs: var HypSmear, dsg: G, dg: G, sg: G) =
   static:
     doAssert(type(dsg[0]) is typeof(hs.state.gf[0]))
     doAssert(type(dg[0])  is typeof(hs.state.gf[0]))
-  let hsp = hs.addr
   let tangents = hs.buildTangentState(dg)
 
-  applyOutputProjectionJvp(dsg, sg, hsp.state.flx, tangents.dflx)
+  hypOutputProjectionJVP(dsg, sg, hs.state.flx, tangents.dflx)
 
-template applyLevel3StapleHvpPhase(hs, dLevel2Chain, l2, dl2, dsl2,
-                                   dOutputChain: untyped) =
+proc hypOutputStageHVP*(hs: var HypSmear, l2, dl2, dsl2, dOutputChain: auto;
+                        dLevel2Chain: auto) =
   block:
-    var scratch = newLevel3HvpScratch(hs.state.gf, dOutputChain)
+    let hsp = hs.addr
+    var scratch = newLevel3HvpScratch(hsp[].state.gf, dOutputChain)
 
-    forLevel3Pairs(hs, l2, pl1, pl2):
-        discard hs.work.chainShift[nu] ^*! hs.work.outputChain[mu]
-        discard scratch.shiftedOutputChain[mu][nu] ^*! dOutputChain[mu]
-        threadBarrier()
-        symStapleHVP(dLevel2Chain[nu,mu], dLevel2Chain[mu,nu],
-                     scratch.acc1[mu,nu], scratch.acc2[mu,nu],
-                     pl1, pl2, hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][nu],
-                     hs.work.outputChain[mu], hs.work.chainShift[nu],
-                     dl2[nu,mu], dl2[mu,nu], dOutputChain[mu],
-                     dsl2[nu][mu], dsl2[mu][nu], scratch.shiftedOutputChain[mu][nu],
-                     hs.work.tm1, hs.work.tm2, hs.state.sm1[nu], hs.state.sm1[mu])
-        threadBarrier()
+    forLevel3Pairs(hsp[], l2, pl1, pl2):
+      discard hsp[].work.chainShift[nu] ^*! hsp[].work.outputChain[mu]
+      discard scratch.shiftedOutputChain[mu][nu] ^*! dOutputChain[mu]
+      threadBarrier()
+      symStapleHVP(dLevel2Chain[nu,mu], dLevel2Chain[mu,nu],
+                   scratch.acc1[mu,nu], scratch.acc2[mu,nu],
+                   pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
+                   hsp[].work.outputChain[mu], hsp[].work.chainShift[nu],
+                   dl2[nu,mu], dl2[mu,nu], dOutputChain[mu],
+                   dsl2[nu][mu], dsl2[mu][nu], scratch.shiftedOutputChain[mu][nu],
+                   hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+      threadBarrier()
 
 proc smearHVP*[G](hs: var HypSmear, dderiv: G, chain: G, dg: G,
                   dchain: G = @[]) =
@@ -1088,19 +1329,17 @@ proc smearHVP*[G](hs: var HypSmear, dderiv: G, chain: G, dg: G,
   ## Phase 3: second-order adjoints through the three HYP levels
   applyOutputProjectionHVP(work.dOutputChain, hsp.state.flx, chain, dflx, dchain)
   accumulateAndScaleGauge(dderiv, work.dOutputChain, sc.ma3, sc.alp3)
-  applyLevel3StapleHvpPhase(hsp, work.dLevel2Chain, l2, dl2, dsl2, work.dOutputChain)
+  hypOutputStageHVP(hsp[], l2, dl2, dsl2, work.dOutputChain, work.dLevel2Chain)
 
   # Level 2: projection on l2x and staples built from l1
   applyPairProjectionHvpPhase(work.dLevel2Chain, work.dPreProjLevel2Chain, l2, hsp.state.l2x,
                               hsp.work.preProjLevel2Chain, dl2x, dderiv, sc.ma2, sc.alp2)
-  applyPairStapleHvpPhase(2, hsp, l1, dl1, hsp.work.level2Chain, work.dLevel2Chain,
-                          work.dLevel1Chain, hsp.work.tm1, hsp.work.tm2)
+  hypPairStageHVP[2](hsp[], l1, dl1, hsp[].work.level2Chain, work.dLevel2Chain, work.dLevel1Chain)
 
   # Level 1: projection on l1x and staples built directly from gf
   applyPairProjectionHvpPhase(work.dLevel1Chain, work.dPreProjLevel1Chain, l1, hsp.state.l1x,
                               hsp.work.preProjLevel1Chain, dl1x, dderiv, sc.ma1, sc.alp1)
-  applyPairStapleHvpPhase(1, hsp, dgEff, dgEff, hsp.work.level1Chain, work.dLevel1Chain,
-                          dderiv, hsp.work.tm1, hsp.work.tm2)
+  hypPairStageHVP[1](hsp[], dgEff, dgEff, hsp[].work.level1Chain, work.dLevel1Chain, dderiv)
 
 proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
   ## Adjoint of `smearVJP` with respect to `chain`.
@@ -1121,7 +1360,7 @@ proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
   var work = newChainAdjointWorkspace(chainbar, hsp.state.gf)
 
   # Phase 2: backpropagate the Level 1 reverse pair stage
-  applyReversePairStageChainAdjoint(1, hsp, l1, work.level1ChainBar, derivbar, hsp.work.tm1, hsp.work.tm2)
+  hypPairStageChainVJP[1](hsp[], l1, derivbar, work.level1ChainBar)
 
   # Phase 3: apply the Level 1 direct term and projection-chain adjoint
   threads:
@@ -1131,7 +1370,7 @@ proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
   applyPairProjectionChainAdjoint(work.level1ChainBar, l1, hsp.state.l1x)
 
   # Phase 4: backpropagate the Level 2 reverse pair stage
-  applyReversePairStageChainAdjoint(2, hsp, l1, work.level2ChainBar, work.level1ChainBar, hsp.work.tm1, hsp.work.tm2)
+  hypPairStageChainVJP[2](hsp[], l1, work.level1ChainBar, work.level2ChainBar)
 
   # Phase 5: apply the Level 2 direct term and projection-chain adjoint
   threads:
@@ -1141,13 +1380,7 @@ proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
   applyPairProjectionChainAdjoint(work.level2ChainBar, l2, hsp.state.l2x)
 
   # Phase 6: backpropagate the Level 3 reverse pair stage
-  forLevel3Pairs(hsp, l2, pl1, pl2):
-    symStapleVJPChain(work.outputChainBar[mu],
-                      pl1, pl2, hsp.state.stagePairShift[nu][mu], hsp.state.stagePairShift[mu][nu],
-                      work.level2ChainBar[nu,mu], work.level2ChainBar[mu,nu],
-                      hsp.work.chainShift[nu], hsp.work.seedShift[mu],
-                      hsp.work.tm1, hsp.work.tm2, hsp.state.sm1[nu])
-    threadBarrier()
+  hypOutputStageChainVJP(hsp[], l2, work.level2ChainBar, work.outputChainBar)
 
   # Phase 7: apply the Level 3 direct term and finish at the output projection
   threads:
@@ -1158,36 +1391,40 @@ proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
     for mu in 0..<4:
       chainbar[mu].projVJPChain(hsp.state.flx[mu], work.outputChainBar[mu])
 
-template backpropLevel3HvpOutputPhase(hs, dl2bar, dOutputChainBar,
-                                      dLevel2ChainBarFromL3, l2, alp: untyped) =
+proc hypOutputStageHVPVJP*(hs: var HypSmear, dLevel2ChainBarFromL3, l2: auto;
+                           dl2bar, dOutputChainBar: auto) =
   block:
-    var scratch = newLevel3AdjointScratch(hs.state.gf)
+    let hsp = hs.addr
+    let sc = outputStageScales(hsp[])
+    var scratch = newLevel3AdjointScratch(hsp[].state.gf)
 
-    forLevel3Pairs(hs, l2, pl1, pl2):
-      discard hs.work.chainShift[nu] ^*! hs.work.outputChain[mu]
+    forLevel3Pairs(hsp[], l2, pl1, pl2):
+      discard hsp[].work.chainShift[nu] ^*! hsp[].work.outputChain[mu]
       threadBarrier()
       symStapleHVPVJP(dl2bar[nu,mu], dl2bar[mu,nu], scratch.dcbar[mu],
-                      pl1, pl2, hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][nu],
-                      hs.work.outputChain[mu], hs.work.chainShift[nu],
+                      pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
+                      hsp[].work.outputChain[mu], hsp[].work.chainShift[nu],
                       dLevel2ChainBarFromL3[nu,mu], dLevel2ChainBarFromL3[mu,nu],
-                      hs.work.seedShift[nu], hs.work.seedShift[mu],
-                      hs.work.tm1, hs.work.tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+                      hsp[].work.seedShift[nu], hsp[].work.seedShift[mu],
+                      hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
       threadBarrier()
 
-    addScaledGauge(dOutputChainBar, scratch.dcbar, alp)
+    addScaledGauge(dOutputChainBar, scratch.dcbar, sc.alp)
 
-template backpropLevel3TangentPhase(hs, dgEffbar, dl2bar, dOutputTangentBar,
-                                    l2, ma, alp: untyped) =
+proc hypOutputStageJVPVJP*(hs: var HypSmear, dOutputTangentBar, l2: auto;
+                           dgEffbar, dl2bar: auto) =
   block:
+    let hsp = hs.addr
+    let sc = outputStageScales(hsp[])
     threads:
       for mu in 0..<4:
-        dgEffbar[mu] += ma * dOutputTangentBar[mu]
+        dgEffbar[mu] += sc.ma * dOutputTangentBar[mu]
 
-    forLevel3Pairs(hs, l2, pl1, pl2):
-      symStapleJVPVJP(dl2bar[nu,mu], dl2bar[mu,nu], alp,
-                      pl1, pl2, hs.state.stagePairShift[nu][mu], hs.state.stagePairShift[mu][nu],
-                      dOutputTangentBar[mu], hs.work.seedShift[nu],
-                      hs.work.tm1, hs.work.tm2, hs.state.sm1[nu], hs.state.sm1[mu])
+    forLevel3Pairs(hsp[], l2, pl1, pl2):
+      symStapleJVPVJP(dl2bar[nu,mu], dl2bar[mu,nu], sc.alp,
+                      pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
+                      dOutputTangentBar[mu], hsp[].work.seedShift[nu],
+                      hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
       threadBarrier()
 
 proc smearHVPVJP*[G](hs: var HypSmear, gbar: G, derivbar: G, chain: G) =
@@ -1214,32 +1451,28 @@ proc smearHVPVJP*[G](hs: var HypSmear, gbar: G, derivbar: G, chain: G) =
   seedSmearHVPAdjoints(work.dfl1bar, work.dfl2bar, work.dfcbar, derivbar, sc.ma1, sc.ma2, sc.ma3)
 
   # Phase 2: reverse the Level 1 and Level 2 HVP output paths
-  backpropPairHvpOutputPhase(1, hsp, l1, hsp.work.level1Chain, derivbar, work.dgEffbar,
-                             work.dfl1bar, work.dfl1barL2,
-                             l1, hsp.state.l1x, hsp.work.preProjLevel1Chain, sc.alp1,
-                             hsp.work.tm1, hsp.work.tm2)
+  hypPairStageHVPVJP[1](hsp[], l1, hsp[].work.level1Chain, derivbar,
+                        l1, hsp.state.l1x, hsp.work.preProjLevel1Chain,
+                        work.dgEffbar, work.dfl1bar, work.dfl1barL2)
 
-  backpropPairHvpOutputPhase(2, hsp, l1, hsp.work.level2Chain, work.dfl1barL2,
-                             work.dl1bar, work.dfl2bar, work.dfl2barL3,
-                             l2, hsp.state.l2x, hsp.work.preProjLevel2Chain, sc.alp2,
-                             hsp.work.tm1, hsp.work.tm2)
+  hypPairStageHVPVJP[2](hsp[], l1, hsp[].work.level2Chain, work.dfl1barL2,
+                        l2, hsp.state.l2x, hsp.work.preProjLevel2Chain,
+                        work.dl1bar, work.dfl2bar, work.dfl2barL3)
 
   # Phase 3: reverse the Level 3 HVP output path back into the tangent state
-  backpropLevel3HvpOutputPhase(hsp, work.dl2bar, work.dfcbar, work.dfl2barL3, l2, sc.alp3)
+  hypOutputStageHVPVJP(hsp[], work.dfl2barL3, l2, work.dl2bar, work.dfcbar)
   threads:
     for mu in 0..<4:
       work.dflxbar[mu].projHVPVJP_dx(hsp.state.flx[mu], chain[mu], work.dfcbar[mu])
-  backpropLevel3TangentPhase(hsp, work.dgEffbar, work.dl2bar, work.dflxbar, l2, sc.ma3, sc.alp3)
+  hypOutputStageJVPVJP(hsp[], work.dflxbar, l2, work.dgEffbar, work.dl2bar)
 
   # Phase 4: reverse the Level 2 projection and tangent contributions
   accumulateProjectionAdjoint(work.dl2xbar, hsp.state.l2x, hsp.work.preProjLevel2Chain, work.dl2bar, work.dfl2bar)
-  backpropPairTangentPhase(2, hsp, l1, work.dl2xbar, work.dl1bar, work.dgEffbar, sc.ma2, sc.alp2,
-                           hsp.work.tm1, hsp.work.tm2)
+  hypPairStageJVPVJP[2](hsp[], l1, work.dl2xbar, work.dl1bar, work.dgEffbar)
 
   # Phase 5: reverse the Level 1 projection and tangent contributions
   accumulateProjectionAdjoint(work.dl1xbar, hsp.state.l1x, hsp.work.preProjLevel1Chain, work.dl1bar, work.dfl1bar)
-  backpropPairTangentPhase(1, hsp, hsp.state.gf, work.dl1xbar, work.dl1xbar, work.dgEffbar, sc.ma1, sc.alp1,
-                           hsp.work.tm1, hsp.work.tm2)
+  hypPairStageJVPVJP[1](hsp[], hsp[].state.gf, work.dl1xbar, work.dl1xbar, work.dgEffbar)
 
   # Phase 6: return the adjoint with respect to the multiplicative tangent `dg*g`
   threads:
diff --git a/tests/deriv/thyp.nim b/tests/deriv/thyp.nim
index d1f3199c..bd9795d5 100644
--- a/tests/deriv/thyp.nim
+++ b/tests/deriv/thyp.nim
@@ -32,6 +32,13 @@ var info = PerfInfo()
 
 let gc = GaugeActionCoeffs(plaq:6.0)
 
+var shapeHs = lo.newHypSmear(coef)
+var shapeSg = lo.newGauge
+shapeHs.smear(g, shapeSg)
+
+type
+  PairField = type(shapeHs.state.l1x)
+
 let adjCoefCombos = [
   HypCoefs(alpha1:0.0, alpha2:0.0, alpha3:0.0),  # 0: All off
   HypCoefs(alpha1:0.4, alpha2:0.0, alpha3:0.0),  # 1: Only L1
@@ -96,6 +103,7 @@ proc testSmearForceConsistency(): int =
     rtol = 1e-12,
     verbose = true
   )
+  cfg.reportBanner
   var sgClosure = lo.newGauge
   var sgPrealloc = lo.newGauge
   var chain = lo.newGauge
@@ -135,6 +143,147 @@ proc primeHypReverse(hs: var auto; sg, deriv: GaugeField; chain: GaugeField) =
   restoreHypState(hs, sg)
   hs.smearVJP(deriv, chain)
 
+template forPairsTest(mu, nu: untyped; body: untyped) =
+  for mu in 0..<4:
+    for nu in 0..<4:
+      if nu != mu:
+        body
+
+template forThirdTest(mu, nu, a, b: untyped; body: untyped) =
+  for a in 0..<4:
+    if a != mu and a != nu:
+      let b = 1 + 2 + 3 - mu - nu - a
+      discard b
+      body
+
+proc projectPairField(xfield: PairField): PairField =
+  var projected = newOneOf(xfield)
+  threads:
+    forPairsTest(mu, nu):
+      projectU(projected[mu,nu], xfield[mu,nu])
+  projected
+
+proc currentHypL1(hs: var auto): PairField =
+  when compiles(hs.state.l1):
+    result = hs.state.l1
+  else:
+    result = projectPairField(hs.state.l1x)
+
+proc currentHypL2(hs: var auto): PairField =
+  when compiles(hs.state.l2):
+    result = hs.state.l2
+  else:
+    result = projectPairField(hs.state.l2x)
+
+proc makePairFieldGaussianLike(shape: PairField): PairField =
+  var field = newOneOf(shape)
+  threads:
+    forPairsTest(mu, nu):
+      field[mu,nu].gaussian r
+  field
+
+proc perturbGaugeFieldAdd(x: GaugeField; dx: GaugeField; eps: float; res: var GaugeField) =
+  let resPtr = cast[ptr GaugeField](unsafeAddr(res))
+  threads:
+    for mu in 0..<4:
+      resPtr[][mu] := x[mu]
+      resPtr[][mu] += eps * dx[mu]
+
+proc perturbPairFieldAdd(x: PairField; dx: PairField; eps: float; res: var PairField) =
+  let resPtr = cast[ptr PairField](unsafeAddr(res))
+  threads:
+    forPairsTest(mu, nu):
+      resPtr[][mu,nu] := x[mu,nu]
+      resPtr[][mu,nu] += eps * dx[mu,nu]
+
+proc zeroGaugeField(): GaugeField =
+  var z = lo.newGauge
+  threads:
+    for mu in 0..<4:
+      z[mu] := 0
+  z
+
+proc zeroPairField(shape: PairField): PairField =
+  var z = newOneOf(shape)
+  threads:
+    forPairsTest(mu, nu):
+      z[mu,nu] := 0
+  z
+
+proc zeroInPlace(x: var GaugeField) =
+  let xPtr = cast[ptr GaugeField](unsafeAddr(x))
+  threads:
+    for mu in 0..<4:
+      xPtr[][mu] := 0
+
+proc zeroInPlace(x: var PairField) =
+  let xPtr = cast[ptr PairField](unsafeAddr(x))
+  threads:
+    forPairsTest(mu, nu):
+      xPtr[][mu,nu] := 0
+
+proc initShiftedGaugeTangents(dx: GaugeField): auto =
+  var s: array[4,array[4,Shifter[type(dx[0]),type(dx[0][0])]]]
+  forPairsTest(mu, nu):
+    s[mu][nu] = newShifter(dx[mu], nu, 1)
+  threads:
+    forPairsTest(mu, nu):
+      discard s[mu][nu] ^*! dx[mu]
+  s
+
+proc initShiftedStage2Tangents(dl1: PairField): auto =
+  var s: array[4, array[4, array[4, array[2, Shifter[type(dl1[0,1]),type(dl1[0,1][0])]]]]]
+  forPairsTest(mu, nu):
+    forThirdTest(mu, nu, a, b):
+      s[mu][nu][a][0] = newShifter(dl1[a,b], mu, 1)
+      s[mu][nu][a][1] = newShifter(dl1[mu,b], a, 1)
+  threads:
+    forPairsTest(mu, nu):
+      forThirdTest(mu, nu, a, b):
+        discard s[mu][nu][a][0] ^*! dl1[a,b]
+        discard s[mu][nu][a][1] ^*! dl1[mu,b]
+  s
+
+proc initShiftedOutputTangents(dl2: PairField): auto =
+  var s: array[4,array[4,Shifter[type(dl2[0,1]),type(dl2[0,1][0])]]]
+  forPairsTest(mu, nu):
+    s[mu][nu] = newShifter(dl2[mu,nu], nu, 1)
+  threads:
+    forPairsTest(mu, nu):
+      discard s[mu][nu] ^*! dl2[mu,nu]
+  s
+
+proc runMixedAdjointIdentity(
+    cfg: TestConfig,
+    makeBase: auto,
+    makeDir: auto,
+    makeYbar: auto,
+    jvp: auto,
+    vjp: auto
+  ): TestResult =
+  type
+    X = typeof(makeBase(0))
+    DX = typeof(makeDir(0, default(X)))
+    Y = typeof(makeYbar(0, default(X)))
+  reportBanner(cfg)
+  result.name = cfg.name
+  for sample in 0..<cfg.samples:
+    let base = makeBase(sample)
+    let dx = makeDir(sample, base)
+    let ybar = makeYbar(sample, base)
+    var dy = allocLike(ybar)
+    var dxbar = allocLike(dx)
+    jvp(base, dx, dy)
+    vjp(base, ybar, dxbar)
+    let lhs = dotLike(ybar, dy)
+    let rhs = dotLike(dxbar, dx)
+    let err = abs(lhs - rhs)
+    let refVal = max(1.0, max(abs(lhs), abs(rhs)))
+    let rel = err / refVal
+    let ok = err <= max(cfg.atol, cfg.rtol * refVal)
+    reportSimple(cfg, sample, lhs, rhs, err, rel, ok)
+    if ok: inc result.passed else: inc result.failed
+
 template contractedForceJvp(hs, x, forcebar, chain, dg: untyped;
                             dchain: untyped = @[]): untyped =
   ## Compose the clean uncontracted `smearHVP` with the outer
@@ -455,6 +604,221 @@ proc testSmearDerivAdjChain(): int =
   )
   result = res.failed
 
+proc testHypPairStage1JVP(): int =
+  var hs = lo.newHypSmear(coef)
+  let cfg = initTestConfig(
+    name = "L1 stage JVP",
+    samples = 3,
+    eps = 1e-3,
+    scale = 2.0,
+    atol = 1e-5,
+    rtol = 1e-4,
+    fdFactor = 3.0,
+    verbose = true
+  )
+  let res = runFDJVP(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField =
+      g,
+    makeDir = proc(sample: int; x: GaugeField): GaugeField =
+      var dx = lo.newGauge
+      dx.gaussian r
+      dx,
+    makeProbe = proc(sample: int; x: GaugeField): PairField =
+      var hsProbe = lo.newHypSmear(coef)
+      var sgProbe = lo.newGauge
+      hsProbe.smear(x, sgProbe)
+      makePairFieldGaussianLike(currentHypL1(hsProbe)),
+    perturb = proc(x: GaugeField; dx: GaugeField; eps: float; res: var GaugeField) =
+      perturbGaugeFieldAdd(x, dx, eps, res),
+    f = proc(x: GaugeField; res: var PairField) =
+      var sg = lo.newGauge
+      hs.smear(x, sg)
+      var pre = newOneOf(hs.state.l1x)
+      var dummy = newOneOf(hs.state.l1x)
+      hypPairStage[1](hs, dummy, pre, res),
+    jvp = proc(x: GaugeField; dx: GaugeField; res: var PairField) =
+      var sg = lo.newGauge
+      hs.smear(x, sg)
+      var pre0 = newOneOf(hs.state.l1x)
+      var proj0 = newOneOf(hs.state.l1x)
+      var dummy = newOneOf(hs.state.l1x)
+      hypPairStage[1](hs, dummy, pre0, proj0)
+      let ds1 = initShiftedGaugeTangents(dx)
+      var dpre = newOneOf(pre0)
+      hypPairStageJVP[1](hs, dummy, dx, ds1, pre0, proj0, dx, dpre, res)
+  )
+  result = res.failed
+
+proc testHypPairStage2JVP(): int =
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  hs.smear(g, sg)
+  let l1 = currentHypL1(hs)
+  let l2 = currentHypL2(hs)
+  let dgEffZero = zeroGaugeField()
+  let cfg = initTestConfig(
+    name = "L2 stage JVP (pair input)",
+    samples = 3,
+    eps = 1e-3,
+    scale = 2.0,
+    atol = 1e-5,
+    rtol = 1e-4,
+    fdFactor = 3.0,
+    verbose = true
+  )
+  let res = runFDJVP(
+    cfg = cfg,
+    makeBase = proc(sample: int): PairField =
+      l1,
+    makeDir = proc(sample: int; x: PairField): PairField =
+      makePairFieldGaussianLike(x),
+    makeProbe = proc(sample: int; x: PairField): PairField =
+      makePairFieldGaussianLike(l2),
+    perturb = proc(x: PairField; dx: PairField; eps: float; res: var PairField) =
+      perturbPairFieldAdd(x, dx, eps, res),
+    f = proc(x: PairField; res: var PairField) =
+      var pre = newOneOf(hs.state.l2x)
+      hypPairStage[2](hs, x, pre, res),
+    jvp = proc(x: PairField; dx: PairField; res: var PairField) =
+      var pre0 = newOneOf(hs.state.l2x)
+      var proj0 = newOneOf(hs.state.l2x)
+      hypPairStage[2](hs, x, pre0, proj0)
+      let dsl1 = initShiftedStage2Tangents(dx)
+      var dpre = newOneOf(pre0)
+      hypPairStageJVP[2](hs, x, dx, dsl1, pre0, proj0, dgEffZero, dpre, res)
+  )
+  result = res.failed
+
+proc testHypOutputStageJVP(): int =
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  hs.smear(g, sg)
+  let l2 = currentHypL2(hs)
+  let dgEffZero = zeroGaugeField()
+  let cfg = initTestConfig(
+    name = "Output stage JVP (pair input)",
+    samples = 3,
+    eps = 1e-3,
+    scale = 2.0,
+    atol = 1e-5,
+    rtol = 1e-4,
+    fdFactor = 3.0,
+    verbose = true
+  )
+  let res = runFDJVP(
+    cfg = cfg,
+    makeBase = proc(sample: int): PairField =
+      l2,
+    makeDir = proc(sample: int; x: PairField): PairField =
+      makePairFieldGaussianLike(x),
+    makeProbe = proc(sample: int; x: PairField): GaugeField =
+      makeProbe(),
+    perturb = proc(x: PairField; dx: PairField; eps: float; res: var PairField) =
+      perturbPairFieldAdd(x, dx, eps, res),
+    f = proc(x: PairField; res: var GaugeField) =
+      var proj = lo.newGauge
+      hypOutputStage(hs, x, res, proj),
+    jvp = proc(x: PairField; dx: PairField; res: var GaugeField) =
+      let dsl2 = initShiftedOutputTangents(dx)
+      hypOutputStageJVP(hs, x, dx, dsl2, dgEffZero, res)
+  )
+  result = res.failed
+
+proc testHypPairStage1ChainAdjoint(): int =
+  var hs = lo.newHypSmear(coef)
+  let cfg = initTestConfig(
+    name = "L1 stage staple/chain adjoint",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let res = runMixedAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): GaugeField =
+      g,
+    makeDir = proc(sample: int; x: GaugeField): PairField =
+      var hsProbe = lo.newHypSmear(coef)
+      var sgProbe = lo.newGauge
+      hsProbe.smear(x, sgProbe)
+      makePairFieldGaussianLike(currentHypL1(hsProbe)),
+    makeYbar = proc(sample: int; x: GaugeField): GaugeField =
+      makeProbe(),
+    jvp = proc(x: GaugeField; dx: PairField; res: var GaugeField) =
+      var sg = lo.newGauge
+      hs.smear(x, sg)
+      let l1 = currentHypL1(hs)
+      zeroInPlace(res)
+      hypPairStageStapleVJP[1](hs, l1, dx, res),
+    vjp = proc(x: GaugeField; ybar: GaugeField; res: var PairField) =
+      var sg = lo.newGauge
+      hs.smear(x, sg)
+      let l1 = currentHypL1(hs)
+      zeroInPlace(res)
+      hypPairStageChainVJP[1](hs, l1, ybar, res)
+  )
+  result = res.failed
+
+proc testHypPairStage2ChainAdjoint(): int =
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  hs.smear(g, sg)
+  let l1 = currentHypL1(hs)
+  let l2 = currentHypL2(hs)
+  let cfg = initTestConfig(
+    name = "L2 stage staple/chain adjoint",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let res = runMixedAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): int =
+      0,
+    makeDir = proc(sample: int; x: int): PairField =
+      makePairFieldGaussianLike(l2),
+    makeYbar = proc(sample: int; x: int): PairField =
+      makePairFieldGaussianLike(l1),
+    jvp = proc(x: int; dx: PairField; res: var PairField) =
+      zeroInPlace(res)
+      hypPairStageStapleVJP[2](hs, l1, dx, res),
+    vjp = proc(x: int; ybar: PairField; res: var PairField) =
+      zeroInPlace(res)
+      hypPairStageChainVJP[2](hs, l1, ybar, res)
+  )
+  result = res.failed
+
+proc testHypOutputStageChainAdjoint(): int =
+  var hs = lo.newHypSmear(coef)
+  var sg = lo.newGauge
+  hs.smear(g, sg)
+  let l2 = currentHypL2(hs)
+  let cfg = initTestConfig(
+    name = "Output stage staple/chain adjoint",
+    samples = 3,
+    atol = 1e-12,
+    rtol = 1e-10,
+    verbose = true
+  )
+  let res = runMixedAdjointIdentity(
+    cfg = cfg,
+    makeBase = proc(sample: int): int =
+      0,
+    makeDir = proc(sample: int; x: int): GaugeField =
+      makeProbe(),
+    makeYbar = proc(sample: int; x: int): PairField =
+      makePairFieldGaussianLike(l2),
+    jvp = proc(x: int; dx: GaugeField; res: var PairField) =
+      zeroInPlace(res)
+      hypOutputStageStapleVJP(hs, l2, dx, res),
+    vjp = proc(x: int; ybar: PairField; res: var GaugeField) =
+      zeroInPlace(res)
+      hypOutputStageChainVJP(hs, l2, ybar, res)
+  )
+  result = res.failed
+
 ## Test: Pure reverse-mode gradient for <p, force(g)>
 ## This test verifies the full reverse-mode chain:
 ##   T(g) = <p, contractProjectTAH(g, smearVJP(g, gaugeActionDeriv(smear(g))))>
@@ -935,7 +1299,15 @@ fail += testSmearTangentAdjoint()
 fail += testSmearDerivAdjChain()
 fail += testGradForceReverseMode()
 
-# Section D: term-by-term / internal adjoints
+# Section D: individual stage operators
+fail += testHypPairStage1JVP()
+fail += testHypPairStage2JVP()
+fail += testHypOutputStageJVP()
+fail += testHypPairStage1ChainAdjoint()
+fail += testHypPairStage2ChainAdjoint()
+fail += testHypOutputStageChainAdjoint()
+
+# Section E: term-by-term / internal adjoints
 fail += testDgEffConversion()
 fail += testDirectContribution()
 block:
diff --git a/tests/deriv/utils.nim b/tests/deriv/utils.nim
index d7d6a6c5..c9973975 100644
--- a/tests/deriv/utils.nim
+++ b/tests/deriv/utils.nim
@@ -127,6 +127,17 @@ proc allocLike*[T](x: T): T =
       a: allocLike(x.a),
       b: allocLike(x.b)
     )
+  elif T is seq:
+    var y: T
+    y.setLen(x.len)
+    for i in 0..<x.len:
+      y[i] = allocLike(x[i])
+    y
+  elif T is array:
+    var y: T
+    for i in 0..<y.len:
+      y[i] = allocLike(x[i])
+    y
   elif compiles(newOneOf(x)):
     newOneOf(x)
   else:
@@ -140,6 +151,22 @@ proc zeroLike*[T](x: T): T =
       a: zeroLike(x.a),
       b: zeroLike(x.b)
     )
+  elif T is seq:
+    var y = allocLike(x)
+    for i in 0..<x.len:
+      y[i] = zeroLike(x[i])
+    y
+  elif T is array:
+    var y: T
+    for i in 0..<y.len:
+      y[i] = zeroLike(x[i])
+    y
+  elif T is FieldArray:
+    var y = allocLike(x)
+    for i in 0..<y.arr.len:
+      if y.arr[i] != nil:
+        y.arr[i] := 0
+    y
   else:
     var y = allocLike(x)
     when compiles(y := 0):
@@ -240,7 +267,7 @@ proc reportFD*(cfg: TestConfig; sample: int; ana, fd, err, fdErr: float; ok: boo
     echo "Test ", sample, " FAILED: Ana=", ana, " FD=", fd,
          " err=", err, " ±", fdErr
 
-proc reportSimple(cfg: TestConfig; sample: int; lhs, rhs, err, rel: float; ok: bool) =
+proc reportSimple*(cfg: TestConfig; sample: int; lhs, rhs, err, rel: float; ok: bool) =
   if ok:
     if cfg.verbose:
       echo "Test ", sample, " Passed: LHS=", lhs, " RHS=", rhs,
@@ -256,7 +283,7 @@ proc reportCompare*(
     label = ""
   ): bool =
   if label.len > 0:
-    echo "  ", label
+    echo "- ", label
   let err = abs(lhs - rhs)
   let refVal = max(1.0, max(abs(lhs), abs(rhs)))
   let rel = err / refVal

From 99a40bb089b3d140b84b15ff23f50dddd2914c6d Mon Sep 17 00:00:00 2001
From: Xiao-Yong Jin <xjin@anl.gov>
Date: Thu, 12 Mar 2026 11:53:19 -0500
Subject: [PATCH 3/7] gauge/hypsmear: avoid double shift when keepProj in the
 closure smear/force code

---
 src/gauge/hypsmear.nim | 43 ++++++++++++++++++++++++++++--------------
 1 file changed, 29 insertions(+), 14 deletions(-)

diff --git a/src/gauge/hypsmear.nim b/src/gauge/hypsmear.nim
index 63932245..aa178c92 100644
--- a/src/gauge/hypsmear.nim
+++ b/src/gauge/hypsmear.nim
@@ -216,6 +216,13 @@ proc smearGetForce*[G](coef: HypCoefs, gf: G, fl: G,
             l2[mu,nu].proj l2x[mu,nu]
     toc("2")
 
+    when keepProj:
+      for mu in 0..<4:
+        for nu in 0..<4:
+          if nu!=mu:
+            threadBarrier()
+            discard s1[mu][nu] ^*! l2[mu,nu]
+
     for mu in 0..<4:
       flx[mu] := ma3 * gf[mu]
       for nu in 0..<4:
@@ -226,10 +233,10 @@ proc smearGetForce*[G](coef: HypCoefs, gf: G, fl: G,
           else:
             lp1.proj l2x[nu,mu]
             lp2.proj l2x[mu,nu]
-          threadBarrier()
-          discard s1[nu][mu] ^*! lp1
-          discard s1[mu][nu] ^*! lp2
-          threadBarrier()
+            threadBarrier()
+            discard s1[nu][mu] ^*! lp1
+            discard s1[mu][nu] ^*! lp2
+            threadBarrier()
           symStaple(flx[mu], alp3, lp1, lp2,
                     s1[nu][mu], s1[mu][nu], tm1, sm1[nu])
       fl[mu].proj flx[mu]
@@ -263,6 +270,12 @@ proc smearGetForce*[G](coef: HypCoefs, gf: G, fl: G,
       for mu in 0..<4:
         f[mu] := ma3 * fc[mu]
         fc[mu] *= alp3
+      when keepProj:
+        for mu in 0..<4:
+          for nu in 0..<4:
+            if nu!=mu:
+              threadBarrier()
+              discard s1[mu][nu] ^*! l2[mu,nu]
       for mu in 0..<4:
         for nu in 0..<4:
           if nu!=mu:
@@ -272,9 +285,9 @@ proc smearGetForce*[G](coef: HypCoefs, gf: G, fl: G,
             else:
               lp1.proj l2x[nu,mu]
               lp2.proj l2x[mu,nu]
-            threadBarrier()
-            discard s1[nu][mu] ^*! lp1
-            discard s1[mu][nu] ^*! lp2
+              threadBarrier()
+              discard s1[nu][mu] ^*! lp1
+              discard s1[mu][nu] ^*! lp2
             discard fs[nu] ^*! fc[mu]
             threadBarrier()
             symStapleDeriv(fl2[nu,mu], fl2[mu,nu],
@@ -499,20 +512,22 @@ proc newHypSmear*(l: Layout, coef: HypCoefs): auto =
 
 proc initProjectedLevelsImpl(hs: var HypSmear; l1, l2: var auto;
                              populateFromCache: static bool) =
-  let hsp = hs.addr
   when keepProj:
-    l1 = hsp[].state.l1
-    l2 = hsp[].state.l2
+    l1 = hs.state.l1
+    l2 = hs.state.l2
   else:
-    let lo = hsp[].state.gf[0].l
-    type Fld = typeof(hsp[].state.gf[0])
+    let lo = hs.state.gf[0].l
+    type Fld = typeof(hs.state.gf[0])
     l1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
     l2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
     when populateFromCache:
+      let hsp = hs.addr
+      let l1p = l1.addr
+      let l2p = l2.addr
       threads:
         forPairs(mu, nu):
-          l1[mu,nu].proj hsp[].state.l1x[mu,nu]
-          l2[mu,nu].proj hsp[].state.l2x[mu,nu]
+          l1p[][mu,nu].proj hsp.state.l1x[mu,nu]
+          l2p[][mu,nu].proj hsp.state.l2x[mu,nu]
 
 proc initProjectedLevels(hs: var HypSmear; l1, l2: var auto) =
   initProjectedLevelsImpl(hs, l1, l2, true)

From a0221a8af3f62205a25a9fa36aefee6f4cfb7b25 Mon Sep 17 00:00:00 2001
From: Xiao-Yong Jin <xjin@anl.gov>
Date: Thu, 12 Mar 2026 14:36:09 -0500
Subject: [PATCH 4/7] gauge/hypsmear: use L1/L2 suffix instead of static int
 generic

---
 src/gauge/hypsmear.nim | 534 +++++++++++++++++++++++------------------
 tests/deriv/thyp.nim   |  26 +-
 2 files changed, 305 insertions(+), 255 deletions(-)

diff --git a/src/gauge/hypsmear.nim b/src/gauge/hypsmear.nim
index aa178c92..35077f1f 100644
--- a/src/gauge/hypsmear.nim
+++ b/src/gauge/hypsmear.nim
@@ -469,12 +469,13 @@ proc scaleFactors[V:static[int],F,T](hs: HypSmear[V,F,T]): HypScaleFactors {.inl
     ma3: 1 - hs.coef.alpha3,
   )
 
-proc pairStageScales[Stage: static int](hs: HypSmear): auto {.inline.} =
+proc pairStageScalesL1(hs: HypSmear): auto {.inline.} =
   let sc = hs.scaleFactors
-  when Stage == 1:
-    result = (ma: sc.ma1, alp: sc.alp1)
-  else:
-    result = (ma: sc.ma2, alp: sc.alp2)
+  result = (ma: sc.ma1, alp: sc.alp1)
+
+proc pairStageScalesL2(hs: HypSmear): auto {.inline.} =
+  let sc = hs.scaleFactors
+  result = (ma: sc.ma2, alp: sc.alp2)
 
 proc outputStageScales(hs: HypSmear): auto {.inline.} =
   let sc = hs.scaleFactors
@@ -745,138 +746,155 @@ proc hypOutputStageChainVJP*(hs: var HypSmear, l2, seedBar: auto;
                       hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu])
     threadBarrier()
 
-## Pair-stage operator family.
-## Stage 1 corresponds to L1; Stage 2 corresponds to L2.
-proc hypPairStage*[Stage: static int](hs: var HypSmear, pairSrc: auto;
-                                      outX, outProj: auto) =
+## Pair-stage operator family split into explicit Level-1/Level-2 entry points.
+proc hypPairStageL1*(hs: var HypSmear; outX, outProj: auto) =
   let hsp = hs.addr
-  let sc = pairStageScales[Stage](hsp[])
-  when Stage == 1:
-    threads:
-      forPairs(mu, nu):
-        discard hsp[].state.gaugePairShift[mu][nu] ^*! hsp[].state.gf[mu]
+  let sc = pairStageScalesL1(hsp[])
+  threads:
+    forPairs(mu, nu):
+      discard hsp[].state.gaugePairShift[mu][nu] ^*! hsp[].state.gf[mu]
 
   threads:
     forPairs(mu, nu):
       outX[mu,nu] := sc.ma * hsp[].state.gf[mu]
-      when Stage == 1:
-        symStaple(outX[mu,nu], sc.alp, hsp[].state.gf[nu], hsp[].state.gf[mu],
-                  hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                  hsp[].work.tm1, hsp[].state.sm1[nu])
+      symStaple(outX[mu,nu], sc.alp, hsp[].state.gf[nu], hsp[].state.gf[mu],
+                hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                hsp[].work.tm1, hsp[].state.sm1[nu])
+      threadBarrier()
+      outProj[mu,nu].proj outX[mu,nu]
+
+proc hypPairStageL2*(hs: var HypSmear, pairSrc: auto;
+                     outX, outProj: auto) =
+  let hsp = hs.addr
+  let sc = pairStageScalesL2(hsp[])
+  threads:
+    forPairs(mu, nu):
+      outX[mu,nu] := sc.ma * hsp[].state.gf[mu]
+      forThird(mu, nu, a, b):
+        let pl1 = pairSrc[a,b]
+        let pl2 = pairSrc[mu,b]
+        threadBarrier()
+        discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+        discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+        threadBarrier()
+        symStaple(outX[mu,nu], sc.alp, pl1, pl2,
+                  hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                  hsp[].work.tm1, hsp[].state.sm1[a])
         threadBarrier()
-      else:
-        forThird(mu, nu, a, b):
-          let pl1 = pairSrc[a,b]
-          let pl2 = pairSrc[mu,b]
-          threadBarrier()
-          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-          threadBarrier()
-          symStaple(outX[mu,nu], sc.alp, pl1, pl2,
-                    hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                    hsp[].work.tm1, hsp[].state.sm1[a])
-          threadBarrier()
       outProj[mu,nu].proj outX[mu,nu]
 
-proc hypPairStageJVP*[Stage: static int](hs: var HypSmear, pairSrc, tangentSrc,
-                                         shiftedTangents, preProjBase, projBase,
-                                         dgEff: auto;
-                                         preProjOut, tangentOut: auto) =
+proc hypPairStageJVPL1*(hs: var HypSmear, tangentSrc, shiftedTangents,
+                        preProjBase, projBase, dgEff: auto;
+                        preProjOut, tangentOut: auto) =
   let hsp = hs.addr
-  let sc = pairStageScales[Stage](hsp[])
-  when Stage == 1:
-    threads:
-      forPairs(mu, nu):
-        discard hsp[].state.gaugePairShift[mu][nu] ^*! hsp[].state.gf[mu]
+  let sc = pairStageScalesL1(hsp[])
+  threads:
+    forPairs(mu, nu):
+      discard hsp[].state.gaugePairShift[mu][nu] ^*! hsp[].state.gf[mu]
+
+  threads:
+    forPairs(mu, nu):
+      preProjOut[mu,nu] := sc.ma * dgEff[mu]
+      symStapleJVP(preProjOut[mu,nu], sc.alp,
+                   hsp[].state.gf[nu], hsp[].state.gf[mu],
+                   hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                   tangentSrc[nu], tangentSrc[mu],
+                   shiftedTangents[nu][mu], shiftedTangents[mu][nu],
+                   hsp[].work.tm1, hsp[].state.sm1[nu])
+      threadBarrier()
+      tangentOut[mu,nu].projJVP(projBase[mu,nu], preProjBase[mu,nu], preProjOut[mu,nu])
 
+proc hypPairStageJVPL2*(hs: var HypSmear, pairSrc, tangentSrc,
+                        shiftedTangents, preProjBase, projBase,
+                        dgEff: auto;
+                        preProjOut, tangentOut: auto) =
+  let hsp = hs.addr
+  let sc = pairStageScalesL2(hsp[])
   threads:
     forPairs(mu, nu):
       preProjOut[mu,nu] := sc.ma * dgEff[mu]
-      when Stage == 1:
+      forThird(mu, nu, a, b):
+        let pl1 = pairSrc[a,b]
+        let pl2 = pairSrc[mu,b]
+        let dpl1 = tangentSrc[a,b]
+        let dpl2 = tangentSrc[mu,b]
+        threadBarrier()
+        discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+        discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+        discard shiftedTangents[mu][nu][a][0] ^*! dpl1
+        discard shiftedTangents[mu][nu][a][1] ^*! dpl2
+        threadBarrier()
         symStapleJVP(preProjOut[mu,nu], sc.alp,
-                     hsp[].state.gf[nu], hsp[].state.gf[mu],
-                     hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                     tangentSrc[nu], tangentSrc[mu],
-                     shiftedTangents[nu][mu], shiftedTangents[mu][nu],
-                     hsp[].work.tm1, hsp[].state.sm1[nu])
+                     pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                     dpl1, dpl2,
+                     shiftedTangents[mu][nu][a][0], shiftedTangents[mu][nu][a][1],
+                     hsp[].work.tm1, hsp[].state.sm1[a])
         threadBarrier()
-      else:
-        forThird(mu, nu, a, b):
-          let pl1 = pairSrc[a,b]
-          let pl2 = pairSrc[mu,b]
-          let dpl1 = tangentSrc[a,b]
-          let dpl2 = tangentSrc[mu,b]
-          threadBarrier()
-          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-          discard shiftedTangents[mu][nu][a][0] ^*! dpl1
-          discard shiftedTangents[mu][nu][a][1] ^*! dpl2
-          threadBarrier()
-          symStapleJVP(preProjOut[mu,nu], sc.alp,
-                       pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                       dpl1, dpl2,
-                       shiftedTangents[mu][nu][a][0], shiftedTangents[mu][nu][a][1],
-                       hsp[].work.tm1, hsp[].state.sm1[a])
-          threadBarrier()
       tangentOut[mu,nu].projJVP(projBase[mu,nu], preProjBase[mu,nu], preProjOut[mu,nu])
 
-proc hypPairStageStapleVJP*[Stage: static int](hs: var HypSmear, pairSrc, chainIn: auto;
-                                               dst: auto) =
+proc hypPairStageStapleVJPL1*(hs: var HypSmear, chainIn: auto; dst: auto) =
   let hsp = hs.addr
   threads:
     forPairs(mu, nu):
-      when Stage == 1:
-        discard hsp[].work.chainShift[nu] ^* chainIn[mu,nu]
-        symStapleVJP(dst[nu], dst[mu],
-                     hsp[].state.gf[nu], hsp[].state.gf[mu],
-                     hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                     chainIn[mu,nu], hsp[].work.chainShift[nu],
-                     hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+      discard hsp[].work.chainShift[nu] ^* chainIn[mu,nu]
+      symStapleVJP(dst[nu], dst[mu],
+                   hsp[].state.gf[nu], hsp[].state.gf[mu],
+                   hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                   chainIn[mu,nu], hsp[].work.chainShift[nu],
+                   hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+      threadBarrier()
+
+proc hypPairStageStapleVJPL2*(hs: var HypSmear, pairSrc, chainIn: auto;
+                              dst: auto) =
+  let hsp = hs.addr
+  threads:
+    forPairs(mu, nu):
+      forThird(mu, nu, a, b):
+        let pl1 = pairSrc[a,b]
+        let pl2 = pairSrc[mu,b]
         threadBarrier()
-      else:
-        forThird(mu, nu, a, b):
-          let pl1 = pairSrc[a,b]
-          let pl2 = pairSrc[mu,b]
-          threadBarrier()
-          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-          discard hsp[].work.chainShift[a] ^*! chainIn[mu,nu]
-          threadBarrier()
-          symStapleVJP(dst[a,b], dst[mu,b],
-                       pl1, pl2,
-                       hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                       chainIn[mu,nu], hsp[].work.chainShift[a],
-                       hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
-          threadBarrier()
+        discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+        discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+        discard hsp[].work.chainShift[a] ^*! chainIn[mu,nu]
+        threadBarrier()
+        symStapleVJP(dst[a,b], dst[mu,b],
+                     pl1, pl2,
+                     hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                     chainIn[mu,nu], hsp[].work.chainShift[a],
+                     hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
+        threadBarrier()
+
+proc hypPairStageChainVJPL1*(hs: var HypSmear, seedBar: auto; dst: auto) =
+  let hsp = hs.addr
+  threads:
+    forPairs(mu, nu):
+      symStapleVJPChain(dst[mu,nu],
+                        hsp[].state.gf[nu], hsp[].state.gf[mu],
+                        hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                        seedBar[nu], seedBar[mu],
+                        hsp[].work.chainShift[nu], hsp[].work.seedShift[mu],
+                        hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu])
+      threadBarrier()
 
-proc hypPairStageChainVJP*[Stage: static int](hs: var HypSmear, pairSrc, seedBar: auto;
-                                              dst: auto) =
+proc hypPairStageChainVJPL2*(hs: var HypSmear, pairSrc, seedBar: auto;
+                             dst: auto) =
   let hsp = hs.addr
   threads:
     forPairs(mu, nu):
-      when Stage == 1:
+      forThird(mu, nu, a, b):
+        let pl1 = pairSrc[a,b]
+        let pl2 = pairSrc[mu,b]
+        threadBarrier()
+        discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+        discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+        threadBarrier()
         symStapleVJPChain(dst[mu,nu],
-                          hsp[].state.gf[nu], hsp[].state.gf[mu],
-                          hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                          seedBar[nu], seedBar[mu],
-                          hsp[].work.chainShift[nu], hsp[].work.seedShift[mu],
-                          hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu])
+                          pl1, pl2,
+                          hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                          seedBar[a,b], seedBar[mu,b],
+                          hsp[].work.chainShift[a], hsp[].work.seedShift[mu],
+                          hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a])
         threadBarrier()
-      else:
-        forThird(mu, nu, a, b):
-          let pl1 = pairSrc[a,b]
-          let pl2 = pairSrc[mu,b]
-          threadBarrier()
-          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-          threadBarrier()
-          symStapleVJPChain(dst[mu,nu],
-                            pl1, pl2,
-                            hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                            seedBar[a,b], seedBar[mu,b],
-                            hsp[].work.chainShift[a], hsp[].work.seedShift[mu],
-                            hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a])
-          threadBarrier()
 
 template accumulateAndScaleGauge(dst, src, ma, alp: auto) =
   threads:
@@ -906,83 +924,87 @@ template applyPairProjectionHvpPhase(chainBar, dChainBar, projected, xfield,
   applyProjectionHVP(chainBar, dChainBar, projected, xfield, preProjChain, tangent)
   accumulateAndScalePairs(derivHvp, chainBar, ma, alp)
 
-proc hypPairStageHVP*[Stage: static int](hs: var HypSmear, pairSrc, tangentSrc,
-                                         chainSrc, dChainIn: auto;
-                                         dst: auto) =
+proc hypPairStageHVPL1*(hs: var HypSmear, tangentSrc, chainSrc, dChainIn: auto;
+                        dst: auto) =
   block:
     let hsp = hs.addr
     let lo = hsp[].state.gf[0].l
     type Fld = typeof(hsp[].state.gf[0])
-    when Stage == 1:
-      var shiftedPairTangents: array[4, array[4, array[2, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]
-      var shiftedChainTangents: array[4, array[4, Shifter[Fld,type(hsp[].state.gf[0][0])]]]
-      forPairs(mu, nu):
-        shiftedPairTangents[mu][nu][0] = newShifter(tangentSrc[nu], mu, 1)
-        shiftedPairTangents[mu][nu][1] = newShifter(tangentSrc[mu], nu, 1)
-        shiftedChainTangents[mu][nu] = newShifter(dChainIn[mu,nu], nu, 1)
-      var acc1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-      var acc2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+    var shiftedPairTangents: array[4, array[4, array[2, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]
+    var shiftedChainTangents: array[4, array[4, Shifter[Fld,type(hsp[].state.gf[0][0])]]]
+    forPairs(mu, nu):
+      shiftedPairTangents[mu][nu][0] = newShifter(tangentSrc[nu], mu, 1)
+      shiftedPairTangents[mu][nu][1] = newShifter(tangentSrc[mu], nu, 1)
+      shiftedChainTangents[mu][nu] = newShifter(dChainIn[mu,nu], nu, 1)
+    var acc1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+    var acc2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
 
-      threads:
-        forPairs(mu, nu):
-          discard hsp[].work.chainShift[nu] ^* chainSrc[mu,nu]
-          discard shiftedPairTangents[mu][nu][0] ^*! tangentSrc[nu]
-          discard shiftedPairTangents[mu][nu][1] ^*! tangentSrc[mu]
-          discard shiftedChainTangents[mu][nu] ^*! dChainIn[mu,nu]
-          symStapleHVP(dst[nu], dst[mu], acc1[mu,nu], acc2[mu,nu],
-                       hsp[].state.gf[nu], hsp[].state.gf[mu],
-                       hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                       chainSrc[mu,nu], hsp[].work.chainShift[nu],
-                       tangentSrc[nu], tangentSrc[mu], dChainIn[mu,nu],
-                       shiftedPairTangents[mu][nu][0], shiftedPairTangents[mu][nu][1],
-                       shiftedChainTangents[mu][nu],
-                       hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
-          threadBarrier()
-    else:
-      var shiftedPairTangents: array[4, array[4, array[4, array[2, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]]
-      var shiftedChainTangents: array[4, array[4, array[4, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]
+    threads:
       forPairs(mu, nu):
-        forThird(mu, nu, a, b):
-          shiftedPairTangents[mu][nu][a][0] = newShifter(tangentSrc[a,b], mu, 1)
-          shiftedPairTangents[mu][nu][a][1] = newShifter(tangentSrc[mu,b], a, 1)
-          shiftedChainTangents[mu][nu][a] = newShifter(dChainIn[mu,nu], a, 1)
-      var acc1: array[4, array[4, array[4, Fld]]]
-      var acc2: array[4, array[4, array[4, Fld]]]
+        discard hsp[].work.chainShift[nu] ^* chainSrc[mu,nu]
+        discard shiftedPairTangents[mu][nu][0] ^*! tangentSrc[nu]
+        discard shiftedPairTangents[mu][nu][1] ^*! tangentSrc[mu]
+        discard shiftedChainTangents[mu][nu] ^*! dChainIn[mu,nu]
+        symStapleHVP(dst[nu], dst[mu], acc1[mu,nu], acc2[mu,nu],
+                     hsp[].state.gf[nu], hsp[].state.gf[mu],
+                     hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                     chainSrc[mu,nu], hsp[].work.chainShift[nu],
+                     tangentSrc[nu], tangentSrc[mu], dChainIn[mu,nu],
+                     shiftedPairTangents[mu][nu][0], shiftedPairTangents[mu][nu][1],
+                     shiftedChainTangents[mu][nu],
+                     hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+        threadBarrier()
+
+proc hypPairStageHVPL2*(hs: var HypSmear, pairSrc, tangentSrc, chainSrc, dChainIn: auto;
+                        dst: auto) =
+  block:
+    let hsp = hs.addr
+    let lo = hsp[].state.gf[0].l
+    type Fld = typeof(hsp[].state.gf[0])
+    var shiftedPairTangents: array[4, array[4, array[4, array[2, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]]
+    var shiftedChainTangents: array[4, array[4, array[4, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]
+    forPairs(mu, nu):
+      forThird(mu, nu, a, b):
+        shiftedPairTangents[mu][nu][a][0] = newShifter(tangentSrc[a,b], mu, 1)
+        shiftedPairTangents[mu][nu][a][1] = newShifter(tangentSrc[mu,b], a, 1)
+        shiftedChainTangents[mu][nu][a] = newShifter(dChainIn[mu,nu], a, 1)
+    var acc1: array[4, array[4, array[4, Fld]]]
+    var acc2: array[4, array[4, array[4, Fld]]]
+    forPairs(mu, nu):
+      forThird(mu, nu, a, b):
+        acc1[mu][nu][a] = lo.newField(type(hsp[].state.gf[0][0]))
+        acc2[mu][nu][a] = lo.newField(type(hsp[].state.gf[0][0]))
+
+    threads:
       forPairs(mu, nu):
         forThird(mu, nu, a, b):
-          acc1[mu][nu][a] = lo.newField(type(hsp[].state.gf[0][0]))
-          acc2[mu][nu][a] = lo.newField(type(hsp[].state.gf[0][0]))
-
-      threads:
-        forPairs(mu, nu):
-          forThird(mu, nu, a, b):
-            let pl1 = pairSrc[a,b]
-            let pl2 = pairSrc[mu,b]
-            threadBarrier()
-            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-            discard hsp[].work.chainShift[a] ^*! chainSrc[mu,nu]
-            discard shiftedPairTangents[mu][nu][a][0] ^*! tangentSrc[a,b]
-            discard shiftedPairTangents[mu][nu][a][1] ^*! tangentSrc[mu,b]
-            discard shiftedChainTangents[mu][nu][a] ^*! dChainIn[mu,nu]
-            threadBarrier()
-            symStapleHVP(dst[a,b], dst[mu,b],
-                         acc1[mu][nu][a], acc2[mu][nu][a],
-                         pl1, pl2,
-                         hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                         chainSrc[mu,nu], hsp[].work.chainShift[a],
-                         tangentSrc[a,b], tangentSrc[mu,b], dChainIn[mu,nu],
-                         shiftedPairTangents[mu][nu][a][0], shiftedPairTangents[mu][nu][a][1],
-                         shiftedChainTangents[mu][nu][a],
-                         hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
-            threadBarrier()
+          let pl1 = pairSrc[a,b]
+          let pl2 = pairSrc[mu,b]
+          threadBarrier()
+          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+          discard hsp[].work.chainShift[a] ^*! chainSrc[mu,nu]
+          discard shiftedPairTangents[mu][nu][a][0] ^*! tangentSrc[a,b]
+          discard shiftedPairTangents[mu][nu][a][1] ^*! tangentSrc[mu,b]
+          discard shiftedChainTangents[mu][nu][a] ^*! dChainIn[mu,nu]
+          threadBarrier()
+          symStapleHVP(dst[a,b], dst[mu,b],
+                       acc1[mu][nu][a], acc2[mu][nu][a],
+                       pl1, pl2,
+                       hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                       chainSrc[mu,nu], hsp[].work.chainShift[a],
+                       tangentSrc[a,b], tangentSrc[mu,b], dChainIn[mu,nu],
+                       shiftedPairTangents[mu][nu][a][0], shiftedPairTangents[mu][nu][a][1],
+                       shiftedChainTangents[mu][nu][a],
+                       hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
+          threadBarrier()
 
-proc hypPairStageHVPVJP*[Stage: static int](hs: var HypSmear, pairSrc, chainSrc,
-                                            seedBar, projected, xfield, preProjChain: auto;
-                                            pairBarOut, chainBar, nextChainBar: auto) =
+proc hypPairStageHVPVJPL1*(hs: var HypSmear, chainSrc, seedBar,
+                           projected, xfield, preProjChain: auto;
+                           gaugeBarOut, chainBar, nextChainBar: auto) =
   block:
     let hsp = hs.addr
-    let sc = pairStageScales[Stage](hsp[])
+    let sc = pairStageScalesL1(hsp[])
     let lo = hsp[].state.gf[0].l
     type Fld = typeof(hsp[].state.gf[0])
     var dcbar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
@@ -992,33 +1014,15 @@ proc hypPairStageHVPVJP*[Stage: static int](hs: var HypSmear, pairSrc, chainSrc,
 
     threads:
       forPairs(mu, nu):
-        when Stage == 1:
-          discard hsp[].work.chainShift[nu] ^* chainSrc[mu,nu]
-          symStapleHVPVJP(pairBarOut[nu], pairBarOut[mu], dcbar[mu,nu],
-                          hsp[].state.gf[nu], hsp[].state.gf[mu],
-                          hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                          chainSrc[mu,nu], hsp[].work.chainShift[nu],
-                          seedBar[nu], seedBar[mu],
-                          hsp[].work.seedShift[nu], hsp[].work.seedShift[mu],
-                          hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
-          threadBarrier()
-        else:
-          forThird(mu, nu, a, b):
-            let pl1 = pairSrc[a,b]
-            let pl2 = pairSrc[mu,b]
-            threadBarrier()
-            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-            discard hsp[].work.chainShift[a] ^*! chainSrc[mu,nu]
-            threadBarrier()
-            symStapleHVPVJP(pairBarOut[a,b], pairBarOut[mu,b], dcbar[mu,nu],
-                            pl1, pl2,
-                            hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                            chainSrc[mu,nu], hsp[].work.chainShift[a],
-                            seedBar[a,b], seedBar[mu,b],
-                            hsp[].work.seedShift[a], hsp[].work.seedShift[mu],
-                            hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
-            threadBarrier()
+        discard hsp[].work.chainShift[nu] ^* chainSrc[mu,nu]
+        symStapleHVPVJP(gaugeBarOut[nu], gaugeBarOut[mu], dcbar[mu,nu],
+                        hsp[].state.gf[nu], hsp[].state.gf[mu],
+                        hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                        chainSrc[mu,nu], hsp[].work.chainShift[nu],
+                        seedBar[nu], seedBar[mu],
+                        hsp[].work.seedShift[nu], hsp[].work.seedShift[mu],
+                        hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+        threadBarrier()
 
     addScaledPairs(chainBar, dcbar, sc.alp)
 
@@ -1029,38 +1033,88 @@ proc hypPairStageHVPVJP*[Stage: static int](hs: var HypSmear, pairSrc, chainSrc,
           chainBar[mu,nu]
         )
 
-proc hypPairStageJVPVJP*[Stage: static int](hs: var HypSmear, pairSrc, tangentXBar: auto;
-                                            pairBarOut, dgEffbar: auto) =
-  let hsp = hs.addr
-  let sc = pairStageScales[Stage](hsp[])
-  threads:
-    forPairs(mu, nu):
-      dgEffbar[mu] += sc.ma * tangentXBar[mu,nu]
+proc hypPairStageHVPVJPL2*(hs: var HypSmear, pairSrc, chainSrc,
+                           seedBar, projected, xfield, preProjChain: auto;
+                           pairBarOut, chainBar, nextChainBar: auto) =
+  block:
+    let hsp = hs.addr
+    let sc = pairStageScalesL2(hsp[])
+    let lo = hsp[].state.gf[0].l
+    type Fld = typeof(hsp[].state.gf[0])
+    var dcbar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+    threads:
+      forPairs(mu, nu):
+        dcbar[mu,nu] := 0
 
-  threads:
-    forPairs(mu, nu):
-      when Stage == 1:
-        symStapleJVPVJP(dgEffbar[nu], dgEffbar[mu], sc.alp,
-                        hsp[].state.gf[nu], hsp[].state.gf[mu],
-                        hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                        tangentXBar[mu,nu], hsp[].work.seedShift[nu],
-                        hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
-        threadBarrier()
-      else:
+    threads:
+      forPairs(mu, nu):
         forThird(mu, nu, a, b):
           let pl1 = pairSrc[a,b]
           let pl2 = pairSrc[mu,b]
           threadBarrier()
           discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
           discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+          discard hsp[].work.chainShift[a] ^*! chainSrc[mu,nu]
           threadBarrier()
-          symStapleJVPVJP(pairBarOut[a,b], pairBarOut[mu,b], sc.alp,
+          symStapleHVPVJP(pairBarOut[a,b], pairBarOut[mu,b], dcbar[mu,nu],
                           pl1, pl2,
                           hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                          tangentXBar[mu,nu], hsp[].work.seedShift[a],
+                          chainSrc[mu,nu], hsp[].work.chainShift[a],
+                          seedBar[a,b], seedBar[mu,b],
+                          hsp[].work.seedShift[a], hsp[].work.seedShift[mu],
                           hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
           threadBarrier()
 
+    addScaledPairs(chainBar, dcbar, sc.alp)
+
+    threads:
+      forPairs(mu, nu):
+        nextChainBar[mu,nu].projHVPVJP_dc(
+          projected[mu,nu], xfield[mu,nu], preProjChain[mu,nu],
+          chainBar[mu,nu]
+        )
+
+proc hypPairStageJVPVJPL1*(hs: var HypSmear, tangentXBar: auto;
+                           dgEffbar: auto) =
+  let hsp = hs.addr
+  let sc = pairStageScalesL1(hsp[])
+  threads:
+    forPairs(mu, nu):
+      dgEffbar[mu] += sc.ma * tangentXBar[mu,nu]
+
+  threads:
+    forPairs(mu, nu):
+      symStapleJVPVJP(dgEffbar[nu], dgEffbar[mu], sc.alp,
+                      hsp[].state.gf[nu], hsp[].state.gf[mu],
+                      hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                      tangentXBar[mu,nu], hsp[].work.seedShift[nu],
+                      hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+      threadBarrier()
+
+proc hypPairStageJVPVJPL2*(hs: var HypSmear, pairSrc, tangentXBar: auto;
+                           pairBarOut, dgEffbar: auto) =
+  let hsp = hs.addr
+  let sc = pairStageScalesL2(hsp[])
+  threads:
+    forPairs(mu, nu):
+      dgEffbar[mu] += sc.ma * tangentXBar[mu,nu]
+
+  threads:
+    forPairs(mu, nu):
+      forThird(mu, nu, a, b):
+        let pl1 = pairSrc[a,b]
+        let pl2 = pairSrc[mu,b]
+        threadBarrier()
+        discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+        discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+        threadBarrier()
+        symStapleJVPVJP(pairBarOut[a,b], pairBarOut[mu,b], sc.alp,
+                        pl1, pl2,
+                        hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                        tangentXBar[mu,nu], hsp[].work.seedShift[a],
+                        hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
+        threadBarrier()
+
 ## Final output-stage operator family built from L2 pair fields.
 proc hypOutputStage*(hs: var HypSmear, l2: auto; flx, fl: auto) =
   let hsp = hs.addr
@@ -1121,7 +1175,7 @@ proc buildTangentState[L,F,T](hs: var HypSmear[L,F,T], dg: auto): auto =
 
   clearTangentWorkspace(dflx, dl1x, dl2x, dl1, dl2)
 
-  hypPairStageJVP[1](hs, l1, dgEff, ds1, hs.state.l1x, l1, dgEff, dl1x, dl1)
+  hypPairStageJVPL1(hs, dgEff, ds1, hs.state.l1x, l1, dgEff, dl1x, dl1)
 
   var dsl1_l2: array[4, array[4, array[4, array[2, Shifter[Fld,type(hs.state.gf[0][0])]]]]]
   forPairs(mu, nu):
@@ -1129,7 +1183,7 @@ proc buildTangentState[L,F,T](hs: var HypSmear[L,F,T], dg: auto): auto =
       dsl1_l2[mu][nu][a][0] = newShifter(dl1[a,b], mu, 1)
       dsl1_l2[mu][nu][a][1] = newShifter(dl1[mu,b], a, 1)
 
-  hypPairStageJVP[2](hs, l1, dl1, dsl1_l2, hs.state.l2x, l2, dgEff, dl2x, dl2)
+  hypPairStageJVPL2(hs, l1, dl1, dsl1_l2, hs.state.l2x, l2, dgEff, dl2x, dl2)
 
   var dsl2: array[4,array[4,Shifter[Fld,type(hs.state.gf[0][0])]]]
   forPairs(mu, nu):
@@ -1223,7 +1277,7 @@ template buildReverseState(hsp, chain, deriv: untyped; accumulateDirect: static
   projectAndScalePairChain(hsp.work.level2Chain, l2, hsp.state.l2x,
                            hsp.work.preProjLevel2Chain, sc.alp2, deriv, sc.ma2,
                            accumulateDirect)
-  hypPairStageStapleVJP[2](hsp[], l1, hsp[].work.level2Chain, hsp[].work.level1Chain)
+  hypPairStageStapleVJPL2(hsp[], l1, hsp[].work.level2Chain, hsp[].work.level1Chain)
   projectAndScalePairChain(hsp.work.level1Chain, l1, hsp.state.l1x,
                            hsp.work.preProjLevel1Chain, sc.alp1, deriv, sc.ma1,
                            accumulateDirect)
@@ -1241,8 +1295,8 @@ proc smear*(hs: var HypSmear, gf: auto, fl: auto) =
   var l2: typeof(l2x)
   initForwardProjectedLevels(hs, l1, l2)
 
-  hypPairStage[1](hs, l1, l1x, l1)
-  hypPairStage[2](hs, l1, l2x, l2)
+  hypPairStageL1(hs, l1x, l1)
+  hypPairStageL2(hs, l1, l2x, l2)
   hypOutputStage(hs, l2, flx, fl)
 
 proc smearVJP*(hs: var HypSmear, deriv: auto, chain: auto) =
@@ -1252,7 +1306,7 @@ proc smearVJP*(hs: var HypSmear, deriv: auto, chain: auto) =
   ## Backpropagate derivative through hs.smear
   let hsp = hs.addr
   buildReverseState(hsp, chain, deriv, true)
-  hypPairStageStapleVJP[1](hsp[], hsp[].work.level1Chain, hsp[].work.level1Chain, deriv)
+  hypPairStageStapleVJPL1(hsp[], hsp[].work.level1Chain, deriv)
 
 proc hypOutputProjectionJVP*(dst: auto; projected, preProj, tangent: auto) =
   let lo = preProj[0].l
@@ -1349,12 +1403,12 @@ proc smearHVP*[G](hs: var HypSmear, dderiv: G, chain: G, dg: G,
   # Level 2: projection on l2x and staples built from l1
   applyPairProjectionHvpPhase(work.dLevel2Chain, work.dPreProjLevel2Chain, l2, hsp.state.l2x,
                               hsp.work.preProjLevel2Chain, dl2x, dderiv, sc.ma2, sc.alp2)
-  hypPairStageHVP[2](hsp[], l1, dl1, hsp[].work.level2Chain, work.dLevel2Chain, work.dLevel1Chain)
+  hypPairStageHVPL2(hsp[], l1, dl1, hsp[].work.level2Chain, work.dLevel2Chain, work.dLevel1Chain)
 
   # Level 1: projection on l1x and staples built directly from gf
   applyPairProjectionHvpPhase(work.dLevel1Chain, work.dPreProjLevel1Chain, l1, hsp.state.l1x,
                               hsp.work.preProjLevel1Chain, dl1x, dderiv, sc.ma1, sc.alp1)
-  hypPairStageHVP[1](hsp[], dgEff, dgEff, hsp[].work.level1Chain, work.dLevel1Chain, dderiv)
+  hypPairStageHVPL1(hsp[], dgEff, hsp[].work.level1Chain, work.dLevel1Chain, dderiv)
 
 proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
   ## Adjoint of `smearVJP` with respect to `chain`.
@@ -1375,7 +1429,7 @@ proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
   var work = newChainAdjointWorkspace(chainbar, hsp.state.gf)
 
   # Phase 2: backpropagate the Level 1 reverse pair stage
-  hypPairStageChainVJP[1](hsp[], l1, derivbar, work.level1ChainBar)
+  hypPairStageChainVJPL1(hsp[], derivbar, work.level1ChainBar)
 
   # Phase 3: apply the Level 1 direct term and projection-chain adjoint
   threads:
@@ -1385,7 +1439,7 @@ proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
   applyPairProjectionChainAdjoint(work.level1ChainBar, l1, hsp.state.l1x)
 
   # Phase 4: backpropagate the Level 2 reverse pair stage
-  hypPairStageChainVJP[2](hsp[], l1, work.level1ChainBar, work.level2ChainBar)
+  hypPairStageChainVJPL2(hsp[], l1, work.level1ChainBar, work.level2ChainBar)
 
   # Phase 5: apply the Level 2 direct term and projection-chain adjoint
   threads:
@@ -1466,13 +1520,13 @@ proc smearHVPVJP*[G](hs: var HypSmear, gbar: G, derivbar: G, chain: G) =
   seedSmearHVPAdjoints(work.dfl1bar, work.dfl2bar, work.dfcbar, derivbar, sc.ma1, sc.ma2, sc.ma3)
 
   # Phase 2: reverse the Level 1 and Level 2 HVP output paths
-  hypPairStageHVPVJP[1](hsp[], l1, hsp[].work.level1Chain, derivbar,
-                        l1, hsp.state.l1x, hsp.work.preProjLevel1Chain,
-                        work.dgEffbar, work.dfl1bar, work.dfl1barL2)
+  hypPairStageHVPVJPL1(hsp[], hsp[].work.level1Chain, derivbar,
+                       l1, hsp.state.l1x, hsp.work.preProjLevel1Chain,
+                       work.dgEffbar, work.dfl1bar, work.dfl1barL2)
 
-  hypPairStageHVPVJP[2](hsp[], l1, hsp[].work.level2Chain, work.dfl1barL2,
-                        l2, hsp.state.l2x, hsp.work.preProjLevel2Chain,
-                        work.dl1bar, work.dfl2bar, work.dfl2barL3)
+  hypPairStageHVPVJPL2(hsp[], l1, hsp[].work.level2Chain, work.dfl1barL2,
+                       l2, hsp.state.l2x, hsp.work.preProjLevel2Chain,
+                       work.dl1bar, work.dfl2bar, work.dfl2barL3)
 
   # Phase 3: reverse the Level 3 HVP output path back into the tangent state
   hypOutputStageHVPVJP(hsp[], work.dfl2barL3, l2, work.dl2bar, work.dfcbar)
@@ -1483,11 +1537,11 @@ proc smearHVPVJP*[G](hs: var HypSmear, gbar: G, derivbar: G, chain: G) =
 
   # Phase 4: reverse the Level 2 projection and tangent contributions
   accumulateProjectionAdjoint(work.dl2xbar, hsp.state.l2x, hsp.work.preProjLevel2Chain, work.dl2bar, work.dfl2bar)
-  hypPairStageJVPVJP[2](hsp[], l1, work.dl2xbar, work.dl1bar, work.dgEffbar)
+  hypPairStageJVPVJPL2(hsp[], l1, work.dl2xbar, work.dl1bar, work.dgEffbar)
 
   # Phase 5: reverse the Level 1 projection and tangent contributions
   accumulateProjectionAdjoint(work.dl1xbar, hsp.state.l1x, hsp.work.preProjLevel1Chain, work.dl1bar, work.dfl1bar)
-  hypPairStageJVPVJP[1](hsp[], hsp[].state.gf, work.dl1xbar, work.dl1xbar, work.dgEffbar)
+  hypPairStageJVPVJPL1(hsp[], work.dl1xbar, work.dgEffbar)
 
   # Phase 6: return the adjoint with respect to the multiplicative tangent `dg*g`
   threads:
diff --git a/tests/deriv/thyp.nim b/tests/deriv/thyp.nim
index bd9795d5..204d1cbd 100644
--- a/tests/deriv/thyp.nim
+++ b/tests/deriv/thyp.nim
@@ -37,7 +37,7 @@ var shapeSg = lo.newGauge
 shapeHs.smear(g, shapeSg)
 
 type
-  PairField = type(shapeHs.state.l1x)
+  PairField = type(newOneOf(shapeHs.state.l1x))
 
 let adjCoefCombos = [
   HypCoefs(alpha1:0.0, alpha2:0.0, alpha3:0.0),  # 0: All off
@@ -635,18 +635,16 @@ proc testHypPairStage1JVP(): int =
       var sg = lo.newGauge
       hs.smear(x, sg)
       var pre = newOneOf(hs.state.l1x)
-      var dummy = newOneOf(hs.state.l1x)
-      hypPairStage[1](hs, dummy, pre, res),
+      hypPairStageL1(hs, pre, res),
     jvp = proc(x: GaugeField; dx: GaugeField; res: var PairField) =
       var sg = lo.newGauge
       hs.smear(x, sg)
       var pre0 = newOneOf(hs.state.l1x)
       var proj0 = newOneOf(hs.state.l1x)
-      var dummy = newOneOf(hs.state.l1x)
-      hypPairStage[1](hs, dummy, pre0, proj0)
+      hypPairStageL1(hs, pre0, proj0)
       let ds1 = initShiftedGaugeTangents(dx)
       var dpre = newOneOf(pre0)
-      hypPairStageJVP[1](hs, dummy, dx, ds1, pre0, proj0, dx, dpre, res)
+      hypPairStageJVPL1(hs, dx, ds1, pre0, proj0, dx, dpre, res)
   )
   result = res.failed
 
@@ -679,14 +677,14 @@ proc testHypPairStage2JVP(): int =
       perturbPairFieldAdd(x, dx, eps, res),
     f = proc(x: PairField; res: var PairField) =
       var pre = newOneOf(hs.state.l2x)
-      hypPairStage[2](hs, x, pre, res),
+      hypPairStageL2(hs, x, pre, res),
     jvp = proc(x: PairField; dx: PairField; res: var PairField) =
       var pre0 = newOneOf(hs.state.l2x)
       var proj0 = newOneOf(hs.state.l2x)
-      hypPairStage[2](hs, x, pre0, proj0)
+      hypPairStageL2(hs, x, pre0, proj0)
       let dsl1 = initShiftedStage2Tangents(dx)
       var dpre = newOneOf(pre0)
-      hypPairStageJVP[2](hs, x, dx, dsl1, pre0, proj0, dgEffZero, dpre, res)
+      hypPairStageJVPL2(hs, x, dx, dsl1, pre0, proj0, dgEffZero, dpre, res)
   )
   result = res.failed
 
@@ -748,15 +746,13 @@ proc testHypPairStage1ChainAdjoint(): int =
     jvp = proc(x: GaugeField; dx: PairField; res: var GaugeField) =
       var sg = lo.newGauge
       hs.smear(x, sg)
-      let l1 = currentHypL1(hs)
       zeroInPlace(res)
-      hypPairStageStapleVJP[1](hs, l1, dx, res),
+      hypPairStageStapleVJPL1(hs, dx, res),
     vjp = proc(x: GaugeField; ybar: GaugeField; res: var PairField) =
       var sg = lo.newGauge
       hs.smear(x, sg)
-      let l1 = currentHypL1(hs)
       zeroInPlace(res)
-      hypPairStageChainVJP[1](hs, l1, ybar, res)
+      hypPairStageChainVJPL1(hs, ybar, res)
   )
   result = res.failed
 
@@ -783,10 +779,10 @@ proc testHypPairStage2ChainAdjoint(): int =
       makePairFieldGaussianLike(l1),
     jvp = proc(x: int; dx: PairField; res: var PairField) =
       zeroInPlace(res)
-      hypPairStageStapleVJP[2](hs, l1, dx, res),
+      hypPairStageStapleVJPL2(hs, l1, dx, res),
     vjp = proc(x: int; ybar: PairField; res: var PairField) =
       zeroInPlace(res)
-      hypPairStageChainVJP[2](hs, l1, ybar, res)
+      hypPairStageChainVJPL2(hs, l1, ybar, res)
   )
   result = res.failed
 

From 9a3bfa2d2dfb4a74b6be7e3c662212ee69ab3836 Mon Sep 17 00:00:00 2001
From: Xiao-Yong Jin <xjin@anl.gov>
Date: Thu, 12 Mar 2026 17:01:34 -0500
Subject: [PATCH 5/7] maths/projUderiv: moved all projU derivative codes under
 this file

---
 src/maths.nim                 |   2 +
 src/maths/matrixFunctions.nim | 444 ----------------------------------
 src/maths/projUderiv.nim      | 443 +++++++++++++++++++++++++++++++++
 tests/deriv/tprojU.nim        |   2 +-
 4 files changed, 446 insertions(+), 445 deletions(-)

diff --git a/src/maths.nim b/src/maths.nim
index 8783fe44..7e41357e 100644
--- a/src/maths.nim
+++ b/src/maths.nim
@@ -4,6 +4,8 @@ import maths/matrixConcept
 export matrixConcept
 import maths/matrixFunctions
 export matrixFunctions
+import maths/projUderiv
+export projUderiv
 import maths/types
 export types
 
diff --git a/src/maths/matrixFunctions.nim b/src/maths/matrixFunctions.nim
index bcb307a0..1137905f 100644
--- a/src/maths/matrixFunctions.nim
+++ b/src/maths/matrixFunctions.nim
@@ -8,8 +8,6 @@ import matinv
 export matinv
 import matexp
 export matexp
-import projUderiv
-export projUderiv
 getOptimPragmas()
 
 proc determinantN*(a: auto): auto =
@@ -320,448 +318,6 @@ template projectU*(r: var Mat1, eps = 1e-20) =
   t := r
   r.projectU t, eps
 
-# (d/dX') Tr(U'C+C'U) / 2 = (d/dX') Tr(X'CZ+C'XZ) / 2
-# = CZ - (1/2) < Z (X'C + C'X) Z (dY/dX') >
-# (dY/dX') Y + Y (dY/dX') = 2X
-# Z(dY/dX') Y + Y Z(dY/dX') = 2ZX
-# S Y + Y S = U' C Z = Z X' C Z
-# cz-xz^3(x'c+c'x)/2
-# CH: 4528 flops
-proc projectUderiv*(r: var Mat1, u: Mat2, x: Mat3, chain: Mat4, eps = 1e-20) =
-  # U = X (X'X)^{-1/2} = (XX')^{-1/2} X
-  # Y = sqrt(X'X)
-  # Z = (X'X)^{-1/2}
-  # F = C Z - z (Cd U + Ud C) z (dY/dX)
-  var y, z, t1, t2: Mat1
-  #y := x.adj * u
-  #inverse(z, y)
-  projectUrsqrt(z, x)
-  inverse(y, z)
-  #echo "inverse: ", z
-  #QLA_M_eq_M_times_M(d, c, &z);
-  r := chain * z
-  #QLA_M_eq_Ma_times_M(&t1, p, d);
-  t1 := u.adj * r
-  #sylsolve_site(NCARG &t2, &y, &y, &t1);
-  sylsolve(t2, y, t1)
-  #QLA_M_eq_M(&t1, &t2);
-  #QLA_M_peq_Ma(&t1, &t2);
-  #QLA_M_eq_M_times_M(&t2, m, &t1);
-  #QLA_M_meq_M(d, &t2);
-  t1 := t2 + t2.adj
-  r -= x * t1
-
-proc projectUderiv*(r: var Mat1, x: Mat2, c: Mat3) =
-  var u {.noInit.}: type(r)
-  projectU(u, x)
-  #echo u, x, c
-  projectUderiv(r, u, x, c)
-
-proc projectUVJP*(r: var Mat1, u: Mat2, x: Mat3, chain: Mat4, eps = 1e-20) =
-  ## Alias for projectUderiv with naming based on the kernel.
-  projectUderiv(r, u, x, chain, eps)
-
-proc projectUVJP*(r: var Mat1, x: Mat2, c: Mat3) =
-  ## Convenience alias for projectUderiv without providing u.
-  projectUderiv(r, x, c)
-
-proc projectUHVPu*(r: var Mat1, u: Mat2, x: Mat3, c: Mat4, dx: Mat3, dc: Mat4, eps = 1e-20) =
-  ## Analytical directional second derivative of the unitary projection.
-  ##
-  ## Given:
-  ##   u     = projectU(x)
-  ##   r₁(x) = projectUderiv(u, x, chain)
-  ##
-  ## this returns
-  ##   r = d/dε [ r₁(x + ε dx, chain + ε dc) ] |_{ε=0}
-  ##
-  ## by differentiating the algebra used in `projectUderiv`:
-  ##   Z = (X†X)^(-1/2),  Y = Z^(-1)
-  ##   R0 = C Z
-  ##   T2 solves  Y T2 + T2 Y = U† R0
-  ##   S  = T2 + T2†
-  ##   r1 = R0 - X S
-  ##
-  ## Variations:
-  ##   dA  = X† dX + dX† X
-  ##   dY  solves Y dY + dY Y = dA
-  ##   dZ  = - Z dY Z
-  ##   dR0 = dC Z + C dZ
-  ##   dU  = dX Z + X dZ   ,   dU† = Z dX† + dZ X†
-  ##   dB  = dU† R0 + U† dR0          (B = U† R0)
-  ##   dT2 solves Y dT2 + dT2 Y = dB - dY T2 - T2 dY
-  ##   dS  = dT2 + dT2†
-  ##   r   = dR0 - dX S - X dS
-  ##
-  ## This keeps all Sylvester solves local and avoids another outer finite
-  ## difference.
-  discard eps  # parameter kept for API compatibility
-  var z, y: Mat1
-  projectUrsqrt(z, x)   # Z
-  inverse(y, z)         # Y = Z^{-1} = sqrt(X†X)
-
-  # Base first-derivative pieces (same as projectUderiv).
-  var r0, t1, s: Mat1
-  mul(r0, c, z)       # R0 = C Z
-  mul(t1, u.adj, r0)      # B  = U† R0
-  # Solve directly for S: Y S + S Y = B + B†
-  var bSym: Mat1
-  bSym := t1
-  bSym += t1.adj
-  sylsolve(s, y, bSym)
-
-  # dA = X† dX + dX† X
-  var da, tmp: Mat1
-  mul(da, x.adj, dx)
-  mul(tmp, dx.adj, x)
-  da += tmp
-  # Keep dA Hermitian (numerical symmetrization).
-  da = 0.5*(da + da.adj)
-
-  # dY from sqrt(A): Y dY + dY Y = dA
-  var dy: Mat1
-  sylsolve(dy, y, da)
-  dy = 0.5*(dy + dy.adj)
-
-  # dZ via inverse derivative: dZ = - Z dY Z (exact for Z = Y^{-1}).
-  var dz: Mat1
-  var zdy: Mat1
-  mul(zdy, z, dy)
-  mul(dz, zdy, z)
-  dz *= -1
-  dz = 0.5*(dz + dz.adj)
-
-  # dR0 = dC Z + C dZ
-  var dr0: Mat1
-  mul(dr0, dc, z)
-  mul(tmp, c, dz)
-  dr0 += tmp
-
-  # dU = dX Z + X dZ
-  var du: Mat1
-  mul(du, dx, z)
-  mul(tmp, x, dz)
-  du += tmp
-
-  # dU† = Z dX† + dZ X†
-  var duAdj: Mat1
-  mul(duAdj, z, dx.adj)
-  mul(tmp, dz, x.adj)
-  duAdj += tmp               # full dU† including dZ contribution
-
-  # dB pieces
-  # Full variation: dB = dU† R0 + U† dR0
-  # However, the dR0 contribution through U† dR0 is separate from the direct dR0 term.
-  # We include both here as the Sylvester equation for dS needs the full dB.
-  var db: Mat1
-  mul(db, duAdj, r0)           # dU† R0
-  mul(tmp, u.adj, dr0)         # U† dR0
-  db += tmp                    # full dB
-
-  # rhs for dT2: dB - dY T2 - T2 dY
-  # Solve directly for dS: Y dS + dS Y = d(B+B†) - dY S - S dY
-  var rhs, dyS, Sdy: Mat1
-  # Build full symmetric RHS for dS:
-  # RHS = (dB + dB†) - (dY S + S dY)
-  # Note: dY and S are both Hermitian, so dY S + S dY is Hermitian
-  var dBsym: Mat1
-  # dB = dU† R0 + U† dR0, already in db
-  dBsym := db + db.adj
-  # dY S + S dY (already Hermitian since dY and S are Hermitian)
-  mul(dyS, dy, s)
-  mul(Sdy, s, dy)
-  rhs := dBsym
-  rhs -= dyS
-  rhs -= Sdy
-
-  var ds: Mat1
-  sylsolve(ds, y, rhs)
-  ds = 0.5*(ds + ds.adj)  # Ensure ds is Hermitian
-
-  # Final directional second derivative: dR0 - dX S - X dS
-  tmp := 0
-  mul(tmp, dx, s)
-  r := dr0
-  r -= tmp
-  tmp := 0
-  mul(tmp, x, ds)
-  r -= tmp
-
-proc projectUHVPu*(r: var Mat1, u: Mat2, x: Mat3, c: Mat4, dx: Mat3, eps = 1e-20) =
-  ## Compatibility wrapper when no upstream variation dc is provided.
-  var dc {.noInit.}: type(c)
-  dc := 0
-  projectUHVPu(r, u, x, c, dx, dc, eps)
-
-proc projectUHVP*(r: var Mat1, x: Mat2, c: Mat3, dx: Mat2, eps = 1e-20) =
-  ## Convenience wrapper for projectUHVP when only x is given.
-  var u {.noInit.}: type(r)
-  var dc {.noInit.}: type(c)
-  projectU(u, x)
-  dc := 0
-  projectUHVPu(r, u, x, c, dx, dc, eps)
-
-proc projectUHVP*(r: var Mat1, x: Mat2, c: Mat3, dx: Mat2, dc: Mat3, eps = 1e-20) =
-  ## Convenience wrapper including an upstream variation dc.
-  var u {.noInit.}: type(r)
-  projectU(u, x)
-  projectUHVPu(r, u, x, c, dx, dc, eps)
-
-proc projectUJVP*(du: var Mat1, u: Mat2, x: Mat3, dx: Mat3, eps = 1e-20) =
-  ## Forward tangent of unitary projection.
-  ##
-  ## Computes: du = d/dε[ projectU(x + ε dx) ]|_{ε=0}
-  ##
-  ## Given U = X Z where Z = (X†X)^{-1/2}, Y = Z^{-1} = sqrt(X†X):
-  ##   dU = dX Z + X dZ
-  ## where dZ = -Z dY Z and Y dY + dY Y = dA, dA = X† dX + dX† X
-  discard eps
-  var z, y: Mat1
-  projectUrsqrt(z, x)   # Z = (X†X)^{-1/2}
-  inverse(y, z)         # Y = Z^{-1}
-
-  # dA = X† dX + dX† X (Hermitian)
-  var da, tmp: Mat1
-  mul(tmp, x.adj, dx)
-  da := tmp + tmp.adj
-
-  # Solve Y dY + dY Y = dA
-  var dy: Mat1
-  sylsolve(dy, y, da)
-
-  # dZ = -Z dY Z
-  var dz: Mat1
-  tmp := dy * z
-  dz := z * tmp
-  dz := -dz
-
-  # dU = dX Z + X dZ
-  mul(du, dx, z)
-  tmp := x * dz
-  du += tmp
-
-proc projectUJVP*(du: var Mat1, x: Mat2, dx: Mat2, eps = 1e-20) =
-  ## Convenience wrapper when u is not provided.
-  var u {.noInit.}: type(du)
-  projectU(u, x)
-  projectUJVP(du, u, x, dx, eps)
-
-proc projectUVJPChain*(chainbar: var Mat1, u: Mat2, x: Mat3, rbar: Mat4, eps = 1e-20) =
-  ## Adjoint of projectUderiv with respect to the chain input.
-  ##
-  ## Given: r = projectUderiv(u, x, chain) which computes
-  ##   Z = (X†X)^{-1/2}, Y = Z^{-1}
-  ##   R0 = chain * Z
-  ##   T1 = U† * R0
-  ##   sylsolve(T2, Y, T1)  // Y*T2 + T2*Y = T1
-  ##   S = T2 + T2†
-  ##   r = R0 - X*S
-  ##
-  ## This computes chainbar such that ⟨rbar, r⟩ = ⟨chainbar, chain⟩
-  ## for any chain (the map chain → r is linear).
-  ##
-  ## Derivation:
-  ##   r = chain*Z - X*(T2 + T2†) where Y*T2 + T2*Y = U†*chain*Z
-  ##
-  ##   Term 1: chain*Z contributes Z*rbar to chainbar (Z is Hermitian)
-  ##
-  ##   Term 2: -X*S where S = T2 + T2†
-  ##   ⟨-X*S, rbar⟩ = ⟨S, -X†*rbar⟩
-  ##   Let Q = -X†*rbar, then ⟨S, Q⟩ = ⟨T2+T2†, Q⟩ = ⟨T2, Q+Q†⟩
-  ##   Adjoint of Sylvester Y*T2 + T2*Y = T1 gives: Y*T2bar + T2bar*Y = Q+Q†
-  ##   Then ⟨T1, T2bar⟩ = ⟨U†*chain*Z, T2bar⟩ = ⟨chain, U*T2bar*Z⟩
-  ##
-  ##   Total: chainbar = Z*rbar + U*T2bar*Z
-  discard eps
-  var z, y: Mat1
-  projectUrsqrt(z, x)   # Z = (X†X)^{-1/2}
-  inverse(y, z)         # Y = Z^{-1}
-
-  # Q = -X†*rbar, Q_sym = Q + Q†
-  var q, qsym, tmp: Mat1
-  mul(q, x.adj, rbar)
-  q := -q
-  qsym := q + q.adj
-
-  # Solve Y*T2bar + T2bar*Y = Q_sym
-  var t2bar: Mat1
-  sylsolve(t2bar, y, qsym)
-
-  # chainbar = rbar*Z + U*T2bar*Z
-  mul(chainbar, rbar, z)       # rbar*Z (Z is Hermitian, so Z† = Z)
-  mul(tmp, u, t2bar)
-  tmp := tmp * z
-  chainbar += tmp
-
-proc projectUVJPChain*(chainbar: var Mat1, x: Mat2, rbar: Mat3, eps = 1e-20) =
-  ## Convenience wrapper when u is not provided.
-  var u {.noInit.}: type(chainbar)
-  projectU(u, x)
-  projectUVJPChain(chainbar, u, x, rbar, eps)
-
-proc projectUHVPVJP_dx*(dxbar: var Mat1, u: Mat2, x: Mat3, c: Mat4, rbar: auto, eps = 1e-20) =
-  ## Adjoint of projectUHVP with respect to dx.
-  ##
-  ## Given: r = projectUHVPu(u, x, c, dx) which computes (with dc=0):
-  ##   Z = (X†X)^{-1/2}, Y = Z^{-1}
-  ##   R0 = C Z
-  ##   B = U† R0
-  ##   S solves Y S + S Y = B + B†
-  ##   dA = X† dx + dx† X
-  ##   dY solves Y dY + dY Y = dA
-  ##   dZ = -Z dY Z
-  ##   dR0 = C dZ  (since dc=0)
-  ##   dU = dx Z + X dZ
-  ##   dU† = Z dx† + dZ X†
-  ##   dB = dU† R0 + U† dR0
-  ##   dS solves Y dS + dS Y = (dB + dB†) - dY S - S dY
-  ##   r = dR0 - dx S - X dS
-  ##
-  ## This computes dxbar such that ⟨rbar, r⟩ = ⟨dxbar, dx⟩.
-  ##
-  ## dx appears in:
-  ##   1. Direct: -dx S  →  dxbar += -rbar S†  (S is Hermitian, so S† = S)
-  ##   2. dU = dx Z  →  contribution through dU (NOT dU†!)
-  ##   3. dU† = Z dx†  →  contribution through dU† to dB
-  ##   4. dA = X† dx + dx† X  →  flows through dY, dZ
-  ##
-  ## Backward pass traces through the chain of dependencies.
-  discard eps
-  var z, y: Mat1
-  projectUrsqrt(z, x)   # Z = (X†X)^{-1/2}
-  inverse(y, z)         # Y = Z^{-1}
-
-  # Forward quantities needed for adjoint
-  var r0, b, s, tmp: Mat1
-  mul(r0, c, z)         # R0 = C Z
-  mul(b, u.adj, r0)     # B = U† R0
-  var bSym: Mat1
-  bSym := b + b.adj
-  sylsolve(s, y, bSym)  # Y S + S Y = B + B†
-
-  # === Backward pass ===
-
-  # Step 1: Direct term -dx S
-  # ⟨rbar, -dx S⟩ = ⟨-rbar S, dx⟩ (S is Hermitian)
-  mul(dxbar, rbar, s)
-  dxbar := -dxbar
-
-  # Step 2: Trace through dS
-  # r -= X dS, so rbar gives contribution to dSbar
-  # ⟨rbar, -X dS⟩ = ⟨-X† rbar, dS⟩
-  var dSbar: Mat1
-  mul(dSbar, x.adj, rbar)
-  dSbar := -dSbar
-
-  # dS solves Y dS + dS Y = RHS where RHS = (dB+dB†) - dY S - S dY
-  # RHS is Hermitian (sum of Hermitian terms), so dS is already Hermitian.
-  # The 0.5 symmetrization in forward is just numerical cleanup.
-  # Sylvester adjoint: Y dRHSbar + dRHSbar Y = dSbar
-  var dRHSbar: Mat1
-  sylsolve(dRHSbar, y, dSbar)
-
-  # RHS = (dB + dB†) - dY S - S dY
-  # From (dB + dB†): ⟨dRHSbar, dB + dB†⟩ = ⟨dRHSbar + dRHSbar†, dB⟩
-  var dBbar: Mat1
-  dBbar := dRHSbar + dRHSbar.adj
-
-  # From -dY S - S dY: contribution to dYbar
-  # ⟨dRHSbar, -dY S - S dY⟩ = -⟨dRHSbar S + S dRHSbar, dY⟩
-  var dYbar: Mat1
-  var rhsS, Srhs: Mat1
-  mul(rhsS, dRHSbar, s)
-  mul(Srhs, s, dRHSbar)
-  dYbar := -(rhsS + Srhs)
-
-  # Step 3: Trace through dR0
-  # r += dR0 (positive sign), so ⟨rbar, dR0⟩
-  # dR0 = C dZ (since dc=0)
-  # ⟨rbar, C dZ⟩ = ⟨C† rbar, dZ⟩
-  var dZbar: Mat1
-  mul(dZbar, c.adj, rbar)
-
-  # Step 4: Trace through dB = dU† R0 + U† dR0
-  #
-  # From dU† R0: ⟨dBbar, dU† R0⟩
-  # dU† = Z dx† + dZ X†
-  #
-  # For Z dx†: ⟨dBbar, Z dx† R0⟩ = Re(tr(dBbar† Z dx† R0))
-  #   = Re(tr(R0 dBbar† Z dx†)) = Re(tr((Z† dBbar R0†)† dx†))
-  #   = Re(tr(dx (Z† dBbar R0†))) = redot((Z† dBbar R0†)†, dx)
-  #   = redot(R0 dBbar† Z, dx)
-  # So: dxbar += R0 dBbar† Z
-  var tmp2: Mat1
-  mul(tmp, r0, dBbar.adj)
-  mul(tmp2, tmp, z)
-  dxbar += tmp2
-
-  # For dZ X† in dU†: ⟨dBbar, dZ X† R0⟩ = ⟨R0† X dBbar, dZ⟩
-  # Actually: Re(tr(dBbar† dZ X† R0)) = Re(tr(R0 dBbar† dZ X†))
-  #         = Re(tr(X† R0 dBbar† dZ)) = redot((R0 dBbar†)† X, dZ)
-  #         = redot(dBbar R0† X, dZ)? Let me be more careful.
-  # ⟨dBbar, dZ X† R0⟩ = Re(tr(dBbar† dZ X† R0))
-  # Let A = dBbar†, then tr(A dZ X† R0) = tr(X† R0 A dZ)
-  # = redot((X† R0 A)†, dZ) = redot(A† R0† X, dZ) = redot(dBbar R0† X, dZ)
-  # Hmm, let me use the identity: redot(A, B) = Re(tr(A† B))
-  # redot(dBbar, dZ X† R0) = Re(tr(dBbar† dZ X† R0))
-  # We want ⟨?, dZ⟩ form: Re(tr(?† dZ))
-  # tr(dBbar† dZ X† R0) = tr((X† R0 dBbar†)† dZ)†... no, that's wrong
-  # Actually: tr(A B) = tr(B A), so tr(dBbar† dZ X† R0) = tr(X† R0 dBbar† dZ)
-  # = tr((X† R0 dBbar†)† dZ)† = [tr(dZ† (X† R0 dBbar†))]†
-  # For real part: Re(tr(X† R0 dBbar† dZ)) = redot((X† R0 dBbar†)†, dZ) = redot(dBbar R0† X, dZ)
-  # So: dZbar += dBbar R0† X
-  mul(tmp, dBbar, r0.adj)
-  mul(tmp2, tmp, x)
-  dZbar += tmp2
-
-  # From U† dR0: ⟨dBbar, U† dR0⟩ = ⟨U dBbar, dR0⟩
-  # dR0 = C dZ, so ⟨U dBbar, C dZ⟩ = ⟨C† U dBbar, dZ⟩
-  mul(tmp, u, dBbar)
-  mul(tmp2, c.adj, tmp)
-  dZbar += tmp2
-
-  # Step 5: Trace through dZ = -Z dY Z
-  # dZ is then numerically symmetrized: dZ_final = 0.5*(dZ + dZ†)
-  # But since Z and dY are Hermitian, dZ = -Z dY Z is already Hermitian.
-  # So the 0.5 factor is just numerical cleanup and doesn't affect the adjoint.
-  # ⟨dZbar, -Z dY Z⟩ = -⟨Z dZbar Z, dY⟩
-  var zDzbarZ: Mat1
-  mul(tmp, z, dZbar)
-  mul(zDzbarZ, tmp, z)
-  dYbar -= zDzbarZ
-
-  # Step 6: Trace through dY
-  # Y dY + dY Y = dA, then dY is symmetrized: dY_final = 0.5*(dY + dY†)
-  # Since dA is Hermitian and Y is Hermitian, dY is already Hermitian.
-  # So the 0.5 factor is just numerical cleanup.
-  # Sylvester adjoint: Y dAbar + dAbar Y = dYbar
-  var dAbar: Mat1
-  sylsolve(dAbar, y, dYbar)
-
-  # Step 7: Trace through dA = X† dx + dx† X
-  # From X† dx: ⟨dAbar, X† dx⟩ = ⟨X dAbar, dx⟩
-  # From dx† X: ⟨dAbar, dx† X⟩ = ⟨X dAbar†, dx⟩ (verified by test!)
-  # Combined: dxbar += X dAbar + X dAbar†
-  mul(tmp, x, dAbar)
-  dxbar += tmp
-  mul(tmp, x, dAbar.adj)
-  dxbar += tmp
-
-proc projectUHVPVJP_dx*(dxbar: var Mat1, x: Mat2, c: Mat3, rbar: Mat4, eps = 1e-20) =
-  ## Convenience wrapper when u is not provided.
-  var u {.noInit.}: type(dxbar)
-  projectU(u, x)
-  projectUHVPVJP_dx(dxbar, u, x, c, rbar, eps)
-
-proc projectUHVPVJP_dc*(dcbar: var Mat1, u: Mat2, x: Mat3, c: Mat4, rbar: auto, eps = 1e-20) =
-  ## Adjoint of projectUHVP with respect to dc (chain tangent).
-  ## This is identical to the VJP w.r.t. the chain input of projectUVJP.
-  projectUVJPChain(dcbar, u, x, rbar, eps)
-
-proc projectUHVPVJP_dc*(dcbar: var Mat1, x: Mat2, c: Mat3, rbar: Mat4, eps = 1e-20) =
-  ## Convenience wrapper when u is not provided.
-  projectUVJPChain(dcbar, x, rbar, eps)
-
 proc projectSU*(r: var Mat1; x: Mat2) =
   const nc = r.nrows
   var m{.noinit.}: type(r)
diff --git a/src/maths/projUderiv.nim b/src/maths/projUderiv.nim
index 11efd9f9..88ea3bc1 100644
--- a/src/maths/projUderiv.nim
+++ b/src/maths/projUderiv.nim
@@ -1,6 +1,8 @@
 import base
 import complexNumbers
 import matrixConcept
+import matinv
+import matrixFunctions
 import types
 import strformat
 getOptimPragmas()
@@ -148,3 +150,444 @@ proc sylsolve*(x: var Mat1, a: Mat2, c: Mat3) =
   else:
     sylsolveN(x, a, c)
 
+# (d/dX') Tr(U'C+C'U) / 2 = (d/dX') Tr(X'CZ+C'XZ) / 2
+# = CZ - (1/2) < Z (X'C + C'X) Z (dY/dX') >
+# (dY/dX') Y + Y (dY/dX') = 2X
+# Z(dY/dX') Y + Y Z(dY/dX') = 2ZX
+# S Y + Y S = U' C Z = Z X' C Z
+# cz-xz^3(x'c+c'x)/2
+# CH: 4528 flops
+proc projectUderiv*(r: var Mat1, u: Mat2, x: Mat3, chain: Mat4, eps = 1e-20) =
+  # U = X (X'X)^{-1/2} = (XX')^{-1/2} X
+  # Y = sqrt(X'X)
+  # Z = (X'X)^{-1/2}
+  # F = C Z - z (Cd U + Ud C) z (dY/dX)
+  var y, z, t1, t2: Mat1
+  #y := x.adj * u
+  #inverse(z, y)
+  projectUrsqrt(z, x)
+  inverse(y, z)
+  #echo "inverse: ", z
+  #QLA_M_eq_M_times_M(d, c, &z);
+  r := chain * z
+  #QLA_M_eq_Ma_times_M(&t1, p, d);
+  t1 := u.adj * r
+  #sylsolve_site(NCARG &t2, &y, &y, &t1);
+  sylsolve(t2, y, t1)
+  #QLA_M_eq_M(&t1, &t2);
+  #QLA_M_peq_Ma(&t1, &t2);
+  #QLA_M_eq_M_times_M(&t2, m, &t1);
+  #QLA_M_meq_M(d, &t2);
+  t1 := t2 + t2.adj
+  r -= x * t1
+
+proc projectUderiv*(r: var Mat1, x: Mat2, c: Mat3) =
+  var u {.noInit.}: type(r)
+  projectU(u, x)
+  #echo u, x, c
+  projectUderiv(r, u, x, c)
+
+proc projectUVJP*(r: var Mat1, u: Mat2, x: Mat3, chain: Mat4, eps = 1e-20) =
+  ## Alias for projectUderiv with naming based on the kernel.
+  projectUderiv(r, u, x, chain, eps)
+
+proc projectUVJP*(r: var Mat1, x: Mat2, c: Mat3) =
+  ## Convenience alias for projectUderiv without providing u.
+  projectUderiv(r, x, c)
+
+proc projectUHVPu*(r: var Mat1, u: Mat2, x: Mat3, c: Mat4, dx: Mat3, dc: Mat4, eps = 1e-20) =
+  ## Analytical directional second derivative of the unitary projection.
+  ##
+  ## Given:
+  ##   u     = projectU(x)
+  ##   r₁(x) = projectUderiv(u, x, chain)
+  ##
+  ## this returns
+  ##   r = d/dε [ r₁(x + ε dx, chain + ε dc) ] |_{ε=0}
+  ##
+  ## by differentiating the algebra used in `projectUderiv`:
+  ##   Z = (X†X)^(-1/2),  Y = Z^(-1)
+  ##   R0 = C Z
+  ##   T2 solves  Y T2 + T2 Y = U† R0
+  ##   S  = T2 + T2†
+  ##   r1 = R0 - X S
+  ##
+  ## Variations:
+  ##   dA  = X† dX + dX† X
+  ##   dY  solves Y dY + dY Y = dA
+  ##   dZ  = - Z dY Z
+  ##   dR0 = dC Z + C dZ
+  ##   dU  = dX Z + X dZ   ,   dU† = Z dX† + dZ X†
+  ##   dB  = dU† R0 + U† dR0          (B = U† R0)
+  ##   dT2 solves Y dT2 + dT2 Y = dB - dY T2 - T2 dY
+  ##   dS  = dT2 + dT2†
+  ##   r   = dR0 - dX S - X dS
+  ##
+  ## This keeps all Sylvester solves local and avoids another outer finite
+  ## difference.
+  discard eps  # parameter kept for API compatibility
+  var z, y: Mat1
+  projectUrsqrt(z, x)   # Z
+  inverse(y, z)         # Y = Z^{-1} = sqrt(X†X)
+
+  # Base first-derivative pieces (same as projectUderiv).
+  var r0, t1, s: Mat1
+  mul(r0, c, z)            # R0 = C Z
+  mul(t1, u.adj, r0)       # B = U† R0
+  # Solve directly for S: Y S + S Y = B + B†
+  var bSym: Mat1
+  bSym := t1
+  bSym += t1.adj
+  sylsolve(s, y, bSym)
+
+  # dA = X† dX + dX† X
+  var da, tmp: Mat1
+  mul(da, x.adj, dx)
+  mul(tmp, dx.adj, x)
+  da += tmp
+  # Keep dA Hermitian (numerical symmetrization).
+  da = 0.5*(da + da.adj)
+
+  # dY from sqrt(A): Y dY + dY Y = dA
+  var dy: Mat1
+  sylsolve(dy, y, da)
+  dy = 0.5*(dy + dy.adj)
+
+  # dZ via inverse derivative: dZ = - Z dY Z (exact for Z = Y^{-1}).
+  var dz: Mat1
+  var zdy: Mat1
+  mul(zdy, z, dy)
+  mul(dz, zdy, z)
+  dz *= -1
+  dz = 0.5*(dz + dz.adj)
+
+  # dR0 = dC Z + C dZ
+  var dr0: Mat1
+  mul(dr0, dc, z)
+  mul(tmp, c, dz)
+  dr0 += tmp
+
+  # dU = dX Z + X dZ
+  var du: Mat1
+  mul(du, dx, z)
+  mul(tmp, x, dz)
+  du += tmp
+
+  # dU† = Z dX† + dZ X†
+  var duAdj: Mat1
+  mul(duAdj, z, dx.adj)
+  mul(tmp, dz, x.adj)
+  duAdj += tmp  # full dU† including dZ contribution
+
+  # dB pieces
+  # Full variation: dB = dU† R0 + U† dR0
+  # However, the dR0 contribution through U† dR0 is separate from the direct dR0 term.
+  # We include both here as the Sylvester equation for dS needs the full dB.
+  var db: Mat1
+  mul(db, duAdj, r0)     # dU† R0
+  mul(tmp, u.adj, dr0)   # U† dR0
+  db += tmp              # full dB
+
+  # rhs for dT2: dB - dY T2 - T2 dY
+  # Solve directly for dS: Y dS + dS Y = d(B+B†) - dY S - S dY
+  var rhs, dyS, Sdy: Mat1
+  # Build full symmetric RHS for dS:
+  # RHS = (dB + dB†) - (dY S + S dY)
+  # Note: dY and S are both Hermitian, so dY S + S dY is Hermitian
+  var dBsym: Mat1
+  # dB = dU† R0 + U† dR0, already in db
+  dBsym := db + db.adj
+  # dY S + S dY (already Hermitian since dY and S are Hermitian)
+  mul(dyS, dy, s)
+  mul(Sdy, s, dy)
+  rhs := dBsym
+  rhs -= dyS
+  rhs -= Sdy
+
+  var ds: Mat1
+  sylsolve(ds, y, rhs)
+  ds = 0.5*(ds + ds.adj)  # Ensure ds is Hermitian
+
+  # Final directional second derivative: dR0 - dX S - X dS
+  tmp := 0
+  mul(tmp, dx, s)
+  r := dr0
+  r -= tmp
+  tmp := 0
+  mul(tmp, x, ds)
+  r -= tmp
+
+proc projectUHVPu*(r: var Mat1, u: Mat2, x: Mat3, c: Mat4, dx: Mat3, eps = 1e-20) =
+  ## Compatibility wrapper when no upstream variation dc is provided.
+  var dc {.noInit.}: type(c)
+  dc := 0
+  projectUHVPu(r, u, x, c, dx, dc, eps)
+
+proc projectUHVP*(r: var Mat1, x: Mat2, c: Mat3, dx: Mat2, eps = 1e-20) =
+  ## Convenience wrapper for projectUHVP when only x is given.
+  var u {.noInit.}: type(r)
+  var dc {.noInit.}: type(c)
+  projectU(u, x)
+  dc := 0
+  projectUHVPu(r, u, x, c, dx, dc, eps)
+
+proc projectUHVP*(r: var Mat1, x: Mat2, c: Mat3, dx: Mat2, dc: Mat3, eps = 1e-20) =
+  ## Convenience wrapper including an upstream variation dc.
+  var u {.noInit.}: type(r)
+  projectU(u, x)
+  projectUHVPu(r, u, x, c, dx, dc, eps)
+
+proc projectUJVP*(du: var Mat1, u: Mat2, x: Mat3, dx: Mat3, eps = 1e-20) =
+  ## Forward tangent of unitary projection.
+  ##
+  ## Computes: du = d/dε[ projectU(x + ε dx) ]|_{ε=0}
+  ##
+  ## Given U = X Z where Z = (X†X)^{-1/2}, Y = Z^{-1} = sqrt(X†X):
+  ##   dU = dX Z + X dZ
+  ## where dZ = -Z dY Z and Y dY + dY Y = dA, dA = X† dX + dX† X
+  discard eps
+  var z, y: Mat1
+  projectUrsqrt(z, x)   # Z = (X†X)^{-1/2}
+  inverse(y, z)         # Y = Z^{-1}
+
+  # dA = X† dX + dX† X (Hermitian)
+  var da, tmp: Mat1
+  mul(tmp, x.adj, dx)
+  da := tmp + tmp.adj
+
+  # Solve Y dY + dY Y = dA
+  var dy: Mat1
+  sylsolve(dy, y, da)
+
+  # dZ = -Z dY Z
+  var dz: Mat1
+  tmp := dy * z
+  dz := z * tmp
+  dz := -dz
+
+  # dU = dX Z + X dZ
+  mul(du, dx, z)
+  tmp := x * dz
+  du += tmp
+
+proc projectUJVP*(du: var Mat1, x: Mat2, dx: Mat2, eps = 1e-20) =
+  ## Convenience wrapper when u is not provided.
+  var u {.noInit.}: type(du)
+  projectU(u, x)
+  projectUJVP(du, u, x, dx, eps)
+
+proc projectUVJPChain*(chainbar: var Mat1, u: Mat2, x: Mat3, rbar: Mat4, eps = 1e-20) =
+  ## Adjoint of projectUderiv with respect to the chain input.
+  ##
+  ## Given: r = projectUderiv(u, x, chain) which computes
+  ##   Z = (X†X)^{-1/2}, Y = Z^{-1}
+  ##   R0 = chain * Z
+  ##   T1 = U† * R0
+  ##   sylsolve(T2, Y, T1)  // Y*T2 + T2*Y = T1
+  ##   S = T2 + T2†
+  ##   r = R0 - X*S
+  ##
+  ## This computes chainbar such that ⟨rbar, r⟩ = ⟨chainbar, chain⟩
+  ## for any chain (the map chain → r is linear).
+  ##
+  ## Derivation:
+  ##   r = chain*Z - X*(T2 + T2†) where Y*T2 + T2*Y = U†*chain*Z
+  ##
+  ##   Term 1: chain*Z contributes Z*rbar to chainbar (Z is Hermitian)
+  ##
+  ##   Term 2: -X*S where S = T2 + T2†
+  ##   ⟨-X*S, rbar⟩ = ⟨S, -X†*rbar⟩
+  ##   Let Q = -X†*rbar, then ⟨S, Q⟩ = ⟨T2+T2†, Q⟩ = ⟨T2, Q+Q†⟩
+  ##   Adjoint of Sylvester Y*T2 + T2*Y = T1 gives: Y*T2bar + T2bar*Y = Q+Q†
+  ##   Then ⟨T1, T2bar⟩ = ⟨U†*chain*Z, T2bar⟩ = ⟨chain, U*T2bar*Z⟩
+  ##
+  ##   Total: chainbar = Z*rbar + U*T2bar*Z
+  discard eps
+  var z, y: Mat1
+  projectUrsqrt(z, x)   # Z = (X†X)^{-1/2}
+  inverse(y, z)         # Y = Z^{-1}
+
+  # Q = -X†*rbar, Q_sym = Q + Q†
+  var q, qsym, tmp: Mat1
+  mul(q, x.adj, rbar)
+  q := -q
+  qsym := q + q.adj
+
+  # Solve Y*T2bar + T2bar*Y = Q_sym
+  var t2bar: Mat1
+  sylsolve(t2bar, y, qsym)
+
+  # chainbar = rbar*Z + U*T2bar*Z
+  mul(chainbar, rbar, z)  # rbar*Z (Z is Hermitian, so Z† = Z)
+  mul(tmp, u, t2bar)
+  tmp := tmp * z
+  chainbar += tmp
+
+proc projectUVJPChain*(chainbar: var Mat1, x: Mat2, rbar: Mat3, eps = 1e-20) =
+  ## Convenience wrapper when u is not provided.
+  var u {.noInit.}: type(chainbar)
+  projectU(u, x)
+  projectUVJPChain(chainbar, u, x, rbar, eps)
+
+proc projectUHVPVJP_dx*(dxbar: var Mat1, u: Mat2, x: Mat3, c: Mat4, rbar: auto, eps = 1e-20) =
+  ## Adjoint of projectUHVP with respect to dx.
+  ##
+  ## Given: r = projectUHVPu(u, x, c, dx) which computes (with dc=0):
+  ##   Z = (X†X)^{-1/2}, Y = Z^{-1}
+  ##   R0 = C Z
+  ##   B = U† R0
+  ##   S solves Y S + S Y = B + B†
+  ##   dA = X† dx + dx† X
+  ##   dY solves Y dY + dY Y = dA
+  ##   dZ = -Z dY Z
+  ##   dR0 = C dZ  (since dc=0)
+  ##   dU = dx Z + X dZ
+  ##   dU† = Z dx† + dZ X†
+  ##   dB = dU† R0 + U† dR0
+  ##   dS solves Y dS + dS Y = (dB + dB†) - dY S - S dY
+  ##   r = dR0 - dx S - X dS
+  ##
+  ## This computes dxbar such that ⟨rbar, r⟩ = ⟨dxbar, dx⟩.
+  ##
+  ## dx appears in:
+  ##   1. Direct: -dx S  →  dxbar += -rbar S†  (S is Hermitian, so S† = S)
+  ##   2. dU = dx Z  →  contribution through dU (NOT dU†!)
+  ##   3. dU† = Z dx†  →  contribution through dU† to dB
+  ##   4. dA = X† dx + dx† X  →  flows through dY, dZ
+  ##
+  ## Backward pass traces through the chain of dependencies.
+  discard eps
+  var z, y: Mat1
+  projectUrsqrt(z, x)   # Z = (X†X)^{-1/2}
+  inverse(y, z)         # Y = Z^{-1}
+
+  # Forward quantities needed for adjoint
+  var r0, b, s, tmp: Mat1
+  mul(r0, c, z)         # R0 = C Z
+  mul(b, u.adj, r0)     # B = U† R0
+  var bSym: Mat1
+  bSym := b + b.adj
+  sylsolve(s, y, bSym)  # Y S + S Y = B + B†
+
+  # === Backward pass ===
+
+  # Step 1: Direct term -dx S
+  # ⟨rbar, -dx S⟩ = ⟨-rbar S, dx⟩ (S is Hermitian)
+  mul(dxbar, rbar, s)
+  dxbar := -dxbar
+
+  # Step 2: Trace through dS
+  # r -= X dS, so rbar gives contribution to dSbar
+  # ⟨rbar, -X dS⟩ = ⟨-X† rbar, dS⟩
+  var dSbar: Mat1
+  mul(dSbar, x.adj, rbar)
+  dSbar := -dSbar
+
+  # dS solves Y dS + dS Y = RHS where RHS = (dB+dB†) - dY S - S dY
+  # RHS is Hermitian (sum of Hermitian terms), so dS is already Hermitian.
+  # The 0.5 symmetrization in forward is just numerical cleanup.
+  # Sylvester adjoint: Y dRHSbar + dRHSbar Y = dSbar
+  var dRHSbar: Mat1
+  sylsolve(dRHSbar, y, dSbar)
+
+  # RHS = (dB + dB†) - dY S - S dY
+  # From (dB + dB†): ⟨dRHSbar, dB + dB†⟩ = ⟨dRHSbar + dRHSbar†, dB⟩
+  var dBbar: Mat1
+  dBbar := dRHSbar + dRHSbar.adj
+
+  # From -dY S - S dY: contribution to dYbar
+  # ⟨dRHSbar, -dY S - S dY⟩ = -⟨dRHSbar S + S dRHSbar, dY⟩
+  var dYbar: Mat1
+  var rhsS, Srhs: Mat1
+  mul(rhsS, dRHSbar, s)
+  mul(Srhs, s, dRHSbar)
+  dYbar := -(rhsS + Srhs)
+
+  # Step 3: Trace through dR0
+  # r += dR0 (positive sign), so ⟨rbar, dR0⟩
+  # dR0 = C dZ (since dc=0)
+  # ⟨rbar, C dZ⟩ = ⟨C† rbar, dZ⟩
+  var dZbar: Mat1
+  mul(dZbar, c.adj, rbar)
+
+  # Step 4: Trace through dB = dU† R0 + U† dR0
+  #
+  # From dU† R0: ⟨dBbar, dU† R0⟩
+  # dU† = Z dx† + dZ X†
+  #
+  # For Z dx†: ⟨dBbar, Z dx† R0⟩ = Re(tr(dBbar† Z dx† R0))
+  #   = Re(tr(R0 dBbar† Z dx†)) = Re(tr((Z† dBbar R0†)† dx†))
+  #   = Re(tr(dx (Z† dBbar R0†))) = redot((Z† dBbar R0†)†, dx)
+  #   = redot(R0 dBbar† Z, dx)
+  # So: dxbar += R0 dBbar† Z
+  var tmp2: Mat1
+  mul(tmp, r0, dBbar.adj)
+  mul(tmp2, tmp, z)
+  dxbar += tmp2
+
+  # For dZ X† in dU†: ⟨dBbar, dZ X† R0⟩ = ⟨R0† X dBbar, dZ⟩
+  # Actually: Re(tr(dBbar† dZ X† R0)) = Re(tr(R0 dBbar† dZ X†))
+  #         = Re(tr(X† R0 dBbar† dZ)) = redot((R0 dBbar†)† X, dZ)
+  #         = redot(dBbar R0† X, dZ)? Let me be more careful.
+  # ⟨dBbar, dZ X† R0⟩ = Re(tr(dBbar† dZ X† R0))
+  # Let A = dBbar†, then tr(A dZ X† R0) = tr(X† R0 A dZ)
+  # = redot((X† R0 A)†, dZ) = redot(A† R0† X, dZ) = redot(dBbar R0† X, dZ)
+  # Hmm, let me use the identity: redot(A, B) = Re(tr(A† B))
+  # redot(dBbar, dZ X† R0) = Re(tr(dBbar† dZ X† R0))
+  # We want ⟨?, dZ⟩ form: Re(tr(?† dZ))
+  # tr(dBbar† dZ X† R0) = tr((X† R0 dBbar†)† dZ)†... no, that's wrong
+  # Actually: tr(A B) = tr(B A), so tr(dBbar† dZ X† R0) = tr(X† R0 dBbar† dZ)
+  # = tr((X† R0 dBbar†)† dZ)† = [tr(dZ† (X† R0 dBbar†))]†
+  # For real part: Re(tr(X† R0 dBbar† dZ)) = redot((X† R0 dBbar†)†, dZ) = redot(dBbar R0† X, dZ)
+  # So: dZbar += dBbar R0† X
+  mul(tmp, dBbar, r0.adj)
+  mul(tmp2, tmp, x)
+  dZbar += tmp2
+
+  # From U† dR0: ⟨dBbar, U† dR0⟩ = ⟨U dBbar, dR0⟩
+  # dR0 = C dZ, so ⟨U dBbar, C dZ⟩ = ⟨C† U dBbar, dZ⟩
+  mul(tmp, u, dBbar)
+  mul(tmp2, c.adj, tmp)
+  dZbar += tmp2
+
+  # Step 5: Trace through dZ = -Z dY Z
+  # dZ is then numerically symmetrized: dZ_final = 0.5*(dZ + dZ†)
+  # But since Z and dY are Hermitian, dZ = -Z dY Z is already Hermitian.
+  # So the 0.5 factor is just numerical cleanup and doesn't affect the adjoint.
+  # ⟨dZbar, -Z dY Z⟩ = -⟨Z dZbar Z, dY⟩
+  var zDzbarZ: Mat1
+  mul(tmp, z, dZbar)
+  mul(zDzbarZ, tmp, z)
+  dYbar -= zDzbarZ
+
+  # Step 6: Trace through dY
+  # Y dY + dY Y = dA, then dY is symmetrized: dY_final = 0.5*(dY + dY†)
+  # Since dA is Hermitian and Y is Hermitian, dY is already Hermitian.
+  # So the 0.5 factor is just numerical cleanup.
+  # Sylvester adjoint: Y dAbar + dAbar Y = dYbar
+  var dAbar: Mat1
+  sylsolve(dAbar, y, dYbar)
+
+  # Step 7: Trace through dA = X† dx + dx† X
+  # From X† dx: ⟨dAbar, X† dx⟩ = ⟨X dAbar, dx⟩
+  # From dx† X: ⟨dAbar, dx† X⟩ = ⟨X dAbar†, dx⟩ (verified by test!)
+  # Combined: dxbar += X dAbar + X dAbar†
+  mul(tmp, x, dAbar)
+  dxbar += tmp
+  mul(tmp, x, dAbar.adj)
+  dxbar += tmp
+
+proc projectUHVPVJP_dx*(dxbar: var Mat1, x: Mat2, c: Mat3, rbar: Mat4, eps = 1e-20) =
+  ## Convenience wrapper when u is not provided.
+  var u {.noInit.}: type(dxbar)
+  projectU(u, x)
+  projectUHVPVJP_dx(dxbar, u, x, c, rbar, eps)
+
+proc projectUHVPVJP_dc*(dcbar: var Mat1, u: Mat2, x: Mat3, c: Mat4, rbar: auto, eps = 1e-20) =
+  ## Adjoint of projectUHVP with respect to dc (chain tangent).
+  ## This is identical to the VJP w.r.t. the chain input of projectUVJP.
+  projectUVJPChain(dcbar, u, x, rbar, eps)
+
+proc projectUHVPVJP_dc*(dcbar: var Mat1, x: Mat2, c: Mat3, rbar: Mat4, eps = 1e-20) =
+  ## Convenience wrapper when u is not provided.
+  projectUVJPChain(dcbar, x, rbar, eps)
diff --git a/tests/deriv/tprojU.nim b/tests/deriv/tprojU.nim
index 48bad860..8fd50919 100644
--- a/tests/deriv/tprojU.nim
+++ b/tests/deriv/tprojU.nim
@@ -1,6 +1,6 @@
 import math
 import random
-import maths/[matrixFunctions, types, matrixConcept, complexNumbers]
+import maths/[matrixFunctions, projUderiv, types, matrixConcept, complexNumbers]
 import ./utils
 
 var gRng = initRand(123456)

From 646e57d725c7d5abc9b250b63d0e16adf66f8d1c Mon Sep 17 00:00:00 2001
From: Xiao-Yong Jin <xjin@anl.gov>
Date: Thu, 2 Apr 2026 18:10:22 -0500
Subject: [PATCH 6/7] gauge/hypsmear: move allocations to object, encourage
 reuse

---
 src/gauge/hypsmear.nim | 1322 ++++++++++++++++++++++------------------
 1 file changed, 712 insertions(+), 610 deletions(-)

diff --git a/src/gauge/hypsmear.nim b/src/gauge/hypsmear.nim
index 35077f1f..4e52efdf 100644
--- a/src/gauge/hypsmear.nim
+++ b/src/gauge/hypsmear.nim
@@ -7,6 +7,10 @@ when keepProj:
 else:
   static: echo "hypsmear: NOT keeping projected fields"
 
+const
+  psL1 = true
+  psL2 = false
+
 type HypCoefs* = object
   alpha1*: float
   alpha2*: float
@@ -398,59 +402,81 @@ type
     ## between gauge and projected-link phases.
     stagePairShift*: array[4,array[4,Shifter[F,T]]]
     sm1*: array[4,Shifter[F,T]]
+    tm1*: F
     l1x*, l2x*: FieldArray[2,V,T]
     when keepProj:
       l1*, l2*: FieldArray[2,V,T]
     flx*: FieldArray[1,V,T]
 
-  HypScratch[V:static[int],F,T] = object
-    ## Mutable work buffers used by reverse/tangent passes.
-    ## Post-projection chain values for the output, Level 1, and Level 2
-    ## reverse passes. These are scratch, not cached forward state.
+  ## When reused `FieldArray` scratch from these bundles is touched inside
+  ## `threads`, access it through `.addr`/`p[]` aliases. Do not capture a
+  ## local `FieldArray` value directly in a `threads` block; under `refc`
+  ## that pattern caused runtime crashes in derivative-path code.
+  HypReverseStateScratch[V:static[int],F,T] = ref object
     outputChain*: FieldArray[1,V,T]
     level1Chain*, level2Chain*: FieldArray[2,V,T]
-    ## Pre-projection chain values saved specifically for second-order
-    ## projection adjoints.
     preProjLevel1Chain*, preProjLevel2Chain*: FieldArray[2,V,T]
-    ## Reusable forward shifters indexed by direction. `chainShift` is used for
-    ## active chain fields, while `seedShift` stays available as a second
-    ## scratch pool when the higher-order adjoints need an extra shifted seed.
+
+  HypKernelScratch[F,T] = ref object
     chainShift*: array[4,Shifter[F,T]]
     seedShift*: array[4,Shifter[F,T]]
-    tm1*, tm2*: F
+    ## Scratch scalar/matrix temp paired with the reverse/tangent kernel layer.
+    tm2*: F
+
+  HypChainAdjointScratch[V:static[int],F,T] = ref object
+    pairProjectionTmp*: FieldArray[2,V,T]
+    outputChainBar*: seq[F]
+    level1ChainBar*, level2ChainBar*: FieldArray[2,V,T]
+
+  HypTangentScratch[V:static[int],F,T] = ref object
+    tangentDgEff*: seq[F]
+    tangentDflx*: FieldArray[1,V,T]
+    tangentDl1x*, tangentDl2x*, tangentDl1*, tangentDl2*: FieldArray[2,V,T]
+    tangentDs1*, tangentDsl2*: array[4,array[4,Shifter[F,T]]]
+    tangentDsl1L2*: array[4, array[4, array[4, array[2, Shifter[F,T]]]]]
+
+  HypProjectedTmpScratch[V:static[int],F,T] = ref object
+    projectedLevel1Tmp*, projectedLevel2Tmp*: FieldArray[2,V,T]
+
+  HypHvpScratch[V:static[int],F,T] = ref object
+    dOutputChain*: seq[F]
+    dLevel1Chain*, dLevel2Chain*: FieldArray[2,V,T]
+    dPreProjLevel1Chain*, dPreProjLevel2Chain*: FieldArray[2,V,T]
+    hvpL1Acc1*, hvpL1Acc2*: FieldArray[2,V,T]
+    hvpL2Acc1*, hvpL2Acc2*: array[4, array[4, array[4, F]]]
+    hvpL1ShiftedPairTangents*: array[4, array[4, array[2, Shifter[F,T]]]]
+    hvpL1ShiftedChainTangents*: array[4, array[4, Shifter[F,T]]]
+    hvpL2ShiftedPairTangents*: array[4, array[4, array[4, array[2, Shifter[F,T]]]]]
+    hvpL2ShiftedChainTangents*: array[4, array[4, array[4, Shifter[F,T]]]]
+    level3Hvp*: HypLevel3HvpScratch[FieldArray[2,V,T], array[4, array[4, Shifter[F,T]]]]
+
+  HypHvpAdjointScratch[V:static[int],F,T] = ref object
+    dflxbar*, dfcbar*, dgEffbar*: seq[F]
+    dfl1bar*, dfl2bar*: FieldArray[2,V,T]
+    dl1bar*, dl2bar*: FieldArray[2,V,T]
+    dl1xbar*, dl2xbar*: FieldArray[2,V,T]
+    dfl1barL2*, dfl2barL3*: FieldArray[2,V,T]
+    hvpVjpDcbar*: FieldArray[2,V,T]
+    level3Adjoint*: HypLevel3AdjointScratch[seq[F]]
 
   HypSmear*[V:static[int],F,T] = object
     ## Reusable buffers for HYP smearing and its derivative.
     ##
-    ## The forward state is intentionally separated from the mutable scratch so
-    ## it is clear which fields are part of the cached smear result and which
-    ## are transient workspaces for reverse/tangent evaluations.
+    ## The forward state is intentionally separated from the lazy scratch
+    ## bundles so plain `smear` keeps a small footprint. Each derivative family
+    ## allocates its own bundle on first use and then reuses it thereafter.
     coef*: HypCoefs
     state*: HypForwardState[V,F,T]
-    work*: HypScratch[V,F,T]
-
-  HypTangentState[GaugeTangent, OutputTangent, PairField, PairShift] = object
-    dgEff*: GaugeTangent
-    dl1x*, dl1*: PairField
-    dl2x*, dl2*: PairField
-    dflx*: OutputTangent
-    dsl2*: PairShift
-
-  HypHvpWorkspace[GaugeField, PairField] = object
-    dOutputChain*: GaugeField
-    dLevel1Chain*, dLevel2Chain*: PairField
-    dPreProjLevel1Chain*, dPreProjLevel2Chain*: PairField
-
-  HypChainAdjointWorkspace[GaugeField, PairField] = object
-    outputChainBar*: GaugeField
-    level1ChainBar*, level2ChainBar*: PairField
-
-  HypHvpAdjointWorkspace[GaugeField, PairField] = object
-    dflxbar*, dfcbar*, dgEffbar*: GaugeField
-    dfl1bar*, dfl2bar*: PairField
-    dl1bar*, dl2bar*: PairField
-    dl1xbar*, dl2xbar*: PairField
-    dfl1barL2*, dfl2barL3*: PairField
+    reverse*: HypReverseStateScratch[V,F,T]
+    kernel*: HypKernelScratch[F,T]
+    chainAdjoint*: HypChainAdjointScratch[V,F,T]
+    tangent*: HypTangentScratch[V,F,T]
+    projectedTmp*: HypProjectedTmpScratch[V,F,T]
+    hvp*: HypHvpScratch[V,F,T]
+    hvpAdjoint*: HypHvpAdjointScratch[V,F,T]
+
+  ProjectedLevels[PairField] = object
+    l1*, l2*: PairField
 
   HypLevel3HvpScratch[PairField, ShiftField] = object
     shiftedOutputChain*: ShiftField
@@ -469,18 +495,140 @@ proc scaleFactors[V:static[int],F,T](hs: HypSmear[V,F,T]): HypScaleFactors {.inl
     ma3: 1 - hs.coef.alpha3,
   )
 
-proc pairStageScalesL1(hs: HypSmear): auto {.inline.} =
-  let sc = hs.scaleFactors
-  result = (ma: sc.ma1, alp: sc.alp1)
-
-proc pairStageScalesL2(hs: HypSmear): auto {.inline.} =
-  let sc = hs.scaleFactors
-  result = (ma: sc.ma2, alp: sc.alp2)
+template pairStageScales(hs, stage: untyped): untyped =
+  block:
+    let sc = hs.scaleFactors
+    when stage == psL1:
+      (ma: sc.ma1, alp: sc.alp1)
+    else:
+      (ma: sc.ma2, alp: sc.alp2)
 
 proc outputStageScales(hs: HypSmear): auto {.inline.} =
   let sc = hs.scaleFactors
   result = (ma: sc.ma3, alp: sc.alp3)
 
+template allocShiftedTangents(s, f: untyped) =
+  forPairs(mu, nu):
+    s[mu][nu] = newShifter(f[mu], nu, 1)
+
+template allocThirdShiftedTangents(s, f: untyped) =
+  forPairs(mu, nu):
+    forThird(mu, nu, a, b):
+      s[mu][nu][a][0] = newShifter(f[a,b], mu, 1)
+      s[mu][nu][a][1] = newShifter(f[mu,b], a, 1)
+
+template primeShiftedTangentsPtr(sp, fp: untyped) =
+  threads:
+    forPairs(mu, nu):
+      discard sp[][mu][nu] ^*! fp[][mu]
+
+proc ensureReverseStateScratch[V:static[int],F,T](hs: var HypSmear[V,F,T]) =
+  if hs.reverse != nil:
+    return
+  new hs.reverse
+  let lo = hs.state.flx[0].l
+  type GaugeField = typeof(hs.state.flx[0])
+  hs.reverse.outputChain = newFieldArray(lo, GaugeField, 4)
+  hs.reverse.level1Chain = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.reverse.level2Chain = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.reverse.preProjLevel1Chain = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.reverse.preProjLevel2Chain = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+
+proc ensureKernelScratch[V:static[int],F,T](hs: var HypSmear[V,F,T]) =
+  if hs.kernel != nil:
+    return
+  new hs.kernel
+  hs.kernel.tm2.new(hs.state.flx[0].l)
+  for mu in 0..<4:
+    hs.kernel.chainShift[mu] = newShifter(hs.state.flx[mu], mu, 1)
+    hs.kernel.seedShift[mu] = newShifter(hs.state.flx[mu], mu, 1)
+
+proc ensureChainAdjointScratch[V:static[int],F,T](hs: var HypSmear[V,F,T]) =
+  if hs.chainAdjoint != nil:
+    return
+  new hs.chainAdjoint
+  let lo = hs.state.flx[0].l
+  type GaugeField = typeof(hs.state.flx[0])
+  hs.chainAdjoint.pairProjectionTmp = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.chainAdjoint.outputChainBar = lo.newGauge
+  hs.chainAdjoint.level1ChainBar = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.chainAdjoint.level2ChainBar = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+
+proc ensureTangentScratch[V:static[int],F,T](hs: var HypSmear[V,F,T]) =
+  if hs.tangent != nil:
+    return
+  new hs.tangent
+  let lo = hs.state.flx[0].l
+  type GaugeField = typeof(hs.state.flx[0])
+  hs.tangent.tangentDgEff = lo.newGauge
+  hs.tangent.tangentDflx = newFieldArray(lo, GaugeField, 4)
+  hs.tangent.tangentDl1x = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.tangent.tangentDl2x = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.tangent.tangentDl1 = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.tangent.tangentDl2 = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  allocShiftedTangents(hs.tangent.tangentDs1, hs.tangent.tangentDgEff)
+  allocThirdShiftedTangents(hs.tangent.tangentDsl1L2, hs.tangent.tangentDl1)
+  for mu in 0..<4:
+    for nu in 0..<4:
+      if nu != mu:
+        hs.tangent.tangentDsl2[mu][nu] = newShifter(hs.tangent.tangentDl2[mu,nu], nu, 1)
+
+proc ensureProjectedTmpScratch[V:static[int],F,T](hs: var HypSmear[V,F,T]) =
+  if hs.projectedTmp != nil:
+    return
+  new hs.projectedTmp
+  let lo = hs.state.flx[0].l
+  type GaugeField = typeof(hs.state.flx[0])
+  hs.projectedTmp.projectedLevel1Tmp = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.projectedTmp.projectedLevel2Tmp = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+
+proc ensureHvpScratch[V:static[int],F,T](hs: var HypSmear[V,F,T]) =
+  if hs.hvp != nil:
+    return
+  new hs.hvp
+  let lo = hs.state.flx[0].l
+  type GaugeField = typeof(hs.state.flx[0])
+  hs.hvp.dOutputChain = lo.newGauge
+  hs.hvp.dLevel1Chain = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvp.dLevel2Chain = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvp.dPreProjLevel1Chain = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvp.dPreProjLevel2Chain = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvp.level3Hvp.acc1 = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvp.level3Hvp.acc2 = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvp.hvpL1Acc1 = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvp.hvpL1Acc2 = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  forPairs(mu, nu):
+    hs.hvp.level3Hvp.shiftedOutputChain[mu][nu] = newShifter(hs.hvp.dOutputChain[mu], nu, 1)
+    hs.hvp.hvpL1ShiftedPairTangents[mu][nu][0] = newShifter(hs.state.flx[nu], mu, 1)
+    hs.hvp.hvpL1ShiftedPairTangents[mu][nu][1] = newShifter(hs.state.flx[mu], nu, 1)
+    hs.hvp.hvpL1ShiftedChainTangents[mu][nu] = newShifter(hs.hvp.dLevel1Chain[mu,nu], nu, 1)
+    forThird(mu, nu, a, b):
+      hs.hvp.hvpL2Acc1[mu][nu][a] = lo.newField(T)
+      hs.hvp.hvpL2Acc2[mu][nu][a] = lo.newField(T)
+      hs.hvp.hvpL2ShiftedPairTangents[mu][nu][a][0] = newShifter(hs.state.l1x[a,b], mu, 1)
+      hs.hvp.hvpL2ShiftedPairTangents[mu][nu][a][1] = newShifter(hs.state.l1x[mu,b], a, 1)
+      hs.hvp.hvpL2ShiftedChainTangents[mu][nu][a] = newShifter(hs.hvp.dLevel2Chain[mu,nu], a, 1)
+
+proc ensureHvpAdjointScratch[V:static[int],F,T](hs: var HypSmear[V,F,T]) =
+  if hs.hvpAdjoint != nil:
+    return
+  new hs.hvpAdjoint
+  let lo = hs.state.flx[0].l
+  type GaugeField = typeof(hs.state.flx[0])
+  hs.hvpAdjoint.dflxbar = lo.newGauge
+  hs.hvpAdjoint.dfcbar = lo.newGauge
+  hs.hvpAdjoint.dgEffbar = lo.newGauge
+  hs.hvpAdjoint.dfl1bar = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvpAdjoint.dfl2bar = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvpAdjoint.dl1bar = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvpAdjoint.dl2bar = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvpAdjoint.dl1xbar = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvpAdjoint.dl2xbar = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvpAdjoint.dfl1barL2 = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvpAdjoint.dfl2barL3 = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvpAdjoint.hvpVjpDcbar = newFieldArray2(lo, GaugeField, [4,4], mu!=nu)
+  hs.hvpAdjoint.level3Adjoint.dcbar = lo.newGauge
+
 proc newHypSmear*(l: Layout, coef: HypCoefs): auto =
   ## Allocate a reusable environment for HYP smearing and derivatives
   type F = type(l.newGauge[0])
@@ -494,21 +642,13 @@ proc newHypSmear*(l: Layout, coef: HypCoefs): auto =
     hs.state.l1 = newFieldArray2(l,F,[4,4],mu!=nu)
     hs.state.l2 = newFieldArray2(l,F,[4,4],mu!=nu)
   hs.state.flx = newFieldArray(l,F,4)
-  hs.work.outputChain = newFieldArray(l,F,4)
-  hs.work.level1Chain = newFieldArray2(l,F,[4,4],mu!=nu)
-  hs.work.level2Chain = newFieldArray2(l,F,[4,4],mu!=nu)
-  hs.work.preProjLevel1Chain = newFieldArray2(l,F,[4,4],mu!=nu)
-  hs.work.preProjLevel2Chain = newFieldArray2(l,F,[4,4],mu!=nu)
-  hs.work.tm1.new(l)
-  hs.work.tm2.new(l)
+  hs.state.tm1.new(l)
   for mu in 0..<4:
-    hs.state.sm1[mu] = newShifter(hs.work.outputChain[mu], mu, -1)
-    hs.work.chainShift[mu] = newShifter(hs.work.outputChain[mu], mu, 1)
-    hs.work.seedShift[mu] = newShifter(hs.work.outputChain[mu], mu, 1)
+    hs.state.sm1[mu] = newShifter(hs.state.flx[mu], mu, -1)
     for nu in 0..<4:
       if nu != mu:
-        hs.state.gaugePairShift[mu][nu] = newShifter(hs.work.outputChain[mu], nu, 1)
-        hs.state.stagePairShift[mu][nu] = newShifter(hs.work.outputChain[mu], nu, 1)
+        hs.state.gaugePairShift[mu][nu] = newShifter(hs.state.flx[mu], nu, 1)
+        hs.state.stagePairShift[mu][nu] = newShifter(hs.state.flx[mu], nu, 1)
   hs
 
 proc initProjectedLevelsImpl(hs: var HypSmear; l1, l2: var auto;
@@ -517,10 +657,9 @@ proc initProjectedLevelsImpl(hs: var HypSmear; l1, l2: var auto;
     l1 = hs.state.l1
     l2 = hs.state.l2
   else:
-    let lo = hs.state.gf[0].l
-    type Fld = typeof(hs.state.gf[0])
-    l1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-    l2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+    hs.ensureProjectedTmpScratch()
+    l1 = hs.projectedTmp.projectedLevel1Tmp
+    l2 = hs.projectedTmp.projectedLevel2Tmp
     when populateFromCache:
       let hsp = hs.addr
       let l1p = l1.addr
@@ -533,22 +672,16 @@ proc initProjectedLevelsImpl(hs: var HypSmear; l1, l2: var auto;
 proc initProjectedLevels(hs: var HypSmear; l1, l2: var auto) =
   initProjectedLevelsImpl(hs, l1, l2, true)
 
-proc buildGaugeTangent(gf, dg: auto): auto =
-  let lo = gf[0].l
-  var dgEff = lo.newGauge
-  threads:
-    for mu in 0..<gf.len:
-      dgEff[mu] := dg[mu] * gf[mu]
-  dgEff
+proc projectedLevels(hs: var HypSmear): auto =
+  var levels: ProjectedLevels[type(hs.state.l1x)]
+  initProjectedLevels(hs, levels.l1, levels.l2)
+  levels
 
-proc initShiftedTangents(f: auto): auto =
-  var s: array[4,array[4,Shifter[type(f[0]),type(f[0][0])]]]
-  forPairs(mu, nu):
-    s[mu][nu] = newShifter(f[mu], nu, 1)
+proc buildGaugeTangent(dst, gf, dg: auto) =
+  let dstp = dst.addr
   threads:
-    forPairs(mu, nu):
-      discard s[mu][nu] ^*! f[mu]
-  s
+    for mu in 0..<gf.len:
+      dstp[][mu] := dg[mu] * gf[mu]
 
 proc initForwardProjectedLevels(hs: var HypSmear; l1, l2: var auto) =
   ## Allocate the projected Level-1/Level-2 buffers used while rebuilding the
@@ -556,6 +689,11 @@ proc initForwardProjectedLevels(hs: var HypSmear; l1, l2: var auto) =
   ## buffers from cached state.
   initProjectedLevelsImpl(hs, l1, l2, false)
 
+proc forwardProjectedLevels(hs: var HypSmear): auto =
+  var levels: ProjectedLevels[type(hs.state.l1x)]
+  initForwardProjectedLevels(hs, levels.l1, levels.l2)
+  levels
+
 template projectAndScalePairChain(chain, projected, xfield, preProjChain,
                                   alp, derivSink, ma: untyped;
                                   accumulateDirect: static bool) =
@@ -579,14 +717,19 @@ template clearReverseChains(outputChain, level1Chain, level2Chain: auto) =
         level2Chain[mu,nu] := 0
 
 template clearTangentWorkspace(dflx, dl1x, dl2x, dl1, dl2: auto) =
+  let dflxp = dflx.addr
+  let dl1xp = dl1x.addr
+  let dl2xp = dl2x.addr
+  let dl1p = dl1.addr
+  let dl2p = dl2.addr
   threads:
     for mu in 0..<4:
-      dflx[mu] := 0
+      dflxp[][mu] := 0
       forNu(mu, nu):
-        dl1x[mu,nu] := 0
-        dl2x[mu,nu] := 0
-        dl1[mu,nu] := 0
-        dl2[mu,nu] := 0
+        dl1xp[][mu,nu] := 0
+        dl2xp[][mu,nu] := 0
+        dl1p[][mu,nu] := 0
+        dl2p[][mu,nu] := 0
 
 template clearHvpWorkspace(dderiv, dOutputChain, dLevel1Chain, dLevel2Chain: auto) =
   threads:
@@ -624,86 +767,16 @@ template clearHvpAdjointWorkspace(gbar, dflxbar, dfcbar, dgEffbar,
         dl1xbar[mu,nu] := 0
         dl2xbar[mu,nu] := 0
 
-proc newHvpWorkspace(gf: auto): auto =
-  let lo = gf[0].l
-  type Fld = typeof(gf[0])
-  var dOutputChain = lo.newGauge
-  var dLevel1Chain = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dLevel2Chain = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dPreProjLevel1Chain = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dPreProjLevel2Chain = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  HypHvpWorkspace[type(dOutputChain), type(dLevel1Chain)](
-    dOutputChain: dOutputChain,
-    dLevel1Chain: dLevel1Chain,
-    dLevel2Chain: dLevel2Chain,
-    dPreProjLevel1Chain: dPreProjLevel1Chain,
-    dPreProjLevel2Chain: dPreProjLevel2Chain,
-  )
-
-proc newChainAdjointWorkspace(chainbar, gf: auto): auto =
-  let lo = gf[0].l
-  type Fld = typeof(gf[0])
-  var outputChainBar = lo.newGauge
-  var level1ChainBar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var level2ChainBar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  clearChainAdjointWorkspace(outputChainBar, chainbar, level1ChainBar, level2ChainBar)
-  HypChainAdjointWorkspace[type(outputChainBar), type(level1ChainBar)](
-    outputChainBar: outputChainBar,
-    level1ChainBar: level1ChainBar,
-    level2ChainBar: level2ChainBar,
-  )
-
-proc newHvpAdjointWorkspace(gbar, gf: auto): auto =
-  let lo = gf[0].l
-  type Fld = typeof(gf[0])
-  var dflxbar = lo.newGauge
-  var dfcbar = lo.newGauge
-  var dgEffbar = lo.newGauge
-  var dfl1bar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dfl2bar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dl1bar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dl2bar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dl1xbar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dl2xbar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  clearHvpAdjointWorkspace(gbar, dflxbar, dfcbar, dgEffbar,
-                           dfl1bar, dfl2bar, dl1bar, dl2bar, dl1xbar, dl2xbar)
-  var dfl1barL2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dfl2barL3 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  HypHvpAdjointWorkspace[type(dflxbar), type(dfl1bar)](
-    dflxbar: dflxbar,
-    dfcbar: dfcbar,
-    dgEffbar: dgEffbar,
-    dfl1bar: dfl1bar,
-    dfl2bar: dfl2bar,
-    dl1bar: dl1bar,
-    dl2bar: dl2bar,
-    dl1xbar: dl1xbar,
-    dl2xbar: dl2xbar,
-    dfl1barL2: dfl1barL2,
-    dfl2barL3: dfl2barL3,
-  )
-
-proc newLevel3HvpScratch(gf, dOutputChain: auto): auto =
-  let lo = gf[0].l
-  type Fld = typeof(gf[0])
-  var shiftedOutputChain: array[4, array[4, Shifter[Fld,type(gf[0][0])]]]
-  forPairs(mu, nu):
-    shiftedOutputChain[mu][nu] = newShifter(dOutputChain[mu], nu, 1)
-  var acc1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var acc2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  HypLevel3HvpScratch[type(acc1), type(shiftedOutputChain)](
-    shiftedOutputChain: shiftedOutputChain,
-    acc1: acc1,
-    acc2: acc2,
-  )
+template clearHvpAdjointIntermediates(dfl1barL2, dfl2barL3: auto) =
+  threads:
+    forPairs(mu, nu):
+      dfl1barL2[mu,nu] := 0
+      dfl2barL3[mu,nu] := 0
 
-proc newLevel3AdjointScratch(gf: auto): auto =
-  let lo = gf[0].l
-  var dcbar = lo.newGauge
+template clearLevel3AdjointScratch(dcbar: auto) =
   threads:
     for mu in 0..<4:
       dcbar[mu] := 0
-  HypLevel3AdjointScratch[type(dcbar)](dcbar: dcbar)
 
 template primeLevel3PairShifts(hs, l2: auto) =
   threads:
@@ -723,178 +796,223 @@ template forLevel3Pairs(hs, l2, pl1, pl2: untyped; body: untyped) =
 
 proc hypOutputStageStapleVJP*(hs: var HypSmear, l2, outputChain: auto;
                               level2Chain: auto) =
+  hs.ensureKernelScratch()
   let hsp = hs.addr
   forLevel3Pairs(hsp[], l2, pl1, pl2):
     threadBarrier()
-    discard hsp[].work.chainShift[nu] ^*! outputChain[mu]
+    discard hsp[].kernel.chainShift[nu] ^*! outputChain[mu]
     threadBarrier()
     symStapleVJP(level2Chain[nu,mu], level2Chain[mu,nu],
                  pl1, pl2,
                  hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
-                 outputChain[mu], hsp[].work.chainShift[nu],
-                 hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+                 outputChain[mu], hsp[].kernel.chainShift[nu],
+                 hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
     threadBarrier()
 
 proc hypOutputStageChainVJP*(hs: var HypSmear, l2, seedBar: auto;
                              outputChainBar: auto) =
+  hs.ensureKernelScratch()
   let hsp = hs.addr
   forLevel3Pairs(hsp[], l2, pl1, pl2):
     symStapleVJPChain(outputChainBar[mu],
                       pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
                       seedBar[nu,mu], seedBar[mu,nu],
-                      hsp[].work.chainShift[nu], hsp[].work.seedShift[mu],
-                      hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu])
+                      hsp[].kernel.chainShift[nu], hsp[].kernel.seedShift[mu],
+                      hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu])
     threadBarrier()
 
+template primePairStageForwardShifts(hs, stage: untyped) =
+  when stage == psL1:
+    threads:
+      forPairs(mu, nu):
+        discard hs.state.gaugePairShift[mu][nu] ^*! hs.state.gf[mu]
+
+template forPairStageForwardTerms(hs, stage, pairSrc,
+                                  mu, nu, pl1, pl2, sh1, sh2, smDir: untyped;
+                                  body: untyped) =
+  when stage == psL1:
+    let pl1 = hs.state.gf[nu]
+    let pl2 = hs.state.gf[mu]
+    let sh1 = hs.state.gaugePairShift[nu][mu]
+    let sh2 = hs.state.gaugePairShift[mu][nu]
+    let smDir = nu
+    body
+  else:
+    forThird(mu, nu, a, b):
+      let pl1 = pairSrc[a,b]
+      let pl2 = pairSrc[mu,b]
+      let sh1 = hs.state.stagePairShift[nu][mu]
+      let sh2 = hs.state.stagePairShift[mu][a]
+      let smDir = a
+      threadBarrier()
+      discard sh1 ^*! pl1
+      discard sh2 ^*! pl2
+      threadBarrier()
+      body
+      threadBarrier()
+
+template hypPairStageForward(stage, hs, pairSrc, outX, outProj: untyped) =
+  block:
+    let hsp = hs.addr
+    let sc = pairStageScales(hsp[], stage)
+    primePairStageForwardShifts(hsp[], stage)
+
+    threads:
+      forPairs(mu, nu):
+        outX[mu,nu] := sc.ma * hsp[].state.gf[mu]
+        forPairStageForwardTerms(hsp[], stage, pairSrc, mu, nu, pl1, pl2, sh1, sh2, smDir):
+          symStaple(outX[mu,nu], sc.alp, pl1, pl2,
+                    sh1, sh2, hsp[].state.tm1, hsp[].state.sm1[smDir])
+        when stage == psL1:
+          threadBarrier()
+        outProj[mu,nu].proj outX[mu,nu]
+
 ## Pair-stage operator family split into explicit Level-1/Level-2 entry points.
 proc hypPairStageL1*(hs: var HypSmear; outX, outProj: auto) =
-  let hsp = hs.addr
-  let sc = pairStageScalesL1(hsp[])
-  threads:
-    forPairs(mu, nu):
-      discard hsp[].state.gaugePairShift[mu][nu] ^*! hsp[].state.gf[mu]
-
-  threads:
-    forPairs(mu, nu):
-      outX[mu,nu] := sc.ma * hsp[].state.gf[mu]
-      symStaple(outX[mu,nu], sc.alp, hsp[].state.gf[nu], hsp[].state.gf[mu],
-                hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                hsp[].work.tm1, hsp[].state.sm1[nu])
-      threadBarrier()
-      outProj[mu,nu].proj outX[mu,nu]
+  hypPairStageForward(psL1, hs, hs.state.l1x, outX, outProj)
 
 proc hypPairStageL2*(hs: var HypSmear, pairSrc: auto;
                      outX, outProj: auto) =
-  let hsp = hs.addr
-  let sc = pairStageScalesL2(hsp[])
-  threads:
-    forPairs(mu, nu):
-      outX[mu,nu] := sc.ma * hsp[].state.gf[mu]
-      forThird(mu, nu, a, b):
-        let pl1 = pairSrc[a,b]
-        let pl2 = pairSrc[mu,b]
-        threadBarrier()
-        discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-        discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-        threadBarrier()
-        symStaple(outX[mu,nu], sc.alp, pl1, pl2,
-                  hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                  hsp[].work.tm1, hsp[].state.sm1[a])
-        threadBarrier()
-      outProj[mu,nu].proj outX[mu,nu]
-
-proc hypPairStageJVPL1*(hs: var HypSmear, tangentSrc, shiftedTangents,
-                        preProjBase, projBase, dgEff: auto;
-                        preProjOut, tangentOut: auto) =
-  let hsp = hs.addr
-  let sc = pairStageScalesL1(hsp[])
-  threads:
-    forPairs(mu, nu):
-      discard hsp[].state.gaugePairShift[mu][nu] ^*! hsp[].state.gf[mu]
+  hypPairStageForward(psL2, hs, pairSrc, outX, outProj)
 
-  threads:
-    forPairs(mu, nu):
-      preProjOut[mu,nu] := sc.ma * dgEff[mu]
-      symStapleJVP(preProjOut[mu,nu], sc.alp,
-                   hsp[].state.gf[nu], hsp[].state.gf[mu],
-                   hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                   tangentSrc[nu], tangentSrc[mu],
-                   shiftedTangents[nu][mu], shiftedTangents[mu][nu],
-                   hsp[].work.tm1, hsp[].state.sm1[nu])
-      threadBarrier()
-      tangentOut[mu,nu].projJVP(projBase[mu,nu], preProjBase[mu,nu], preProjOut[mu,nu])
-
-proc hypPairStageJVPL2*(hs: var HypSmear, pairSrc, tangentSrc,
-                        shiftedTangents, preProjBase, projBase,
-                        dgEff: auto;
-                        preProjOut, tangentOut: auto) =
-  let hsp = hs.addr
-  let sc = pairStageScalesL2(hsp[])
-  threads:
-    forPairs(mu, nu):
-      preProjOut[mu,nu] := sc.ma * dgEff[mu]
-      forThird(mu, nu, a, b):
-        let pl1 = pairSrc[a,b]
-        let pl2 = pairSrc[mu,b]
-        let dpl1 = tangentSrc[a,b]
-        let dpl2 = tangentSrc[mu,b]
-        threadBarrier()
-        discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-        discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-        discard shiftedTangents[mu][nu][a][0] ^*! dpl1
-        discard shiftedTangents[mu][nu][a][1] ^*! dpl2
-        threadBarrier()
-        symStapleJVP(preProjOut[mu,nu], sc.alp,
-                     pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                     dpl1, dpl2,
-                     shiftedTangents[mu][nu][a][0], shiftedTangents[mu][nu][a][1],
-                     hsp[].work.tm1, hsp[].state.sm1[a])
-        threadBarrier()
-      tangentOut[mu,nu].projJVP(projBase[mu,nu], preProjBase[mu,nu], preProjOut[mu,nu])
+template hypPairStageJVPPtr(stage, hsp, pairSrc, tangentSrc, shiftedTangents,
+                         preProjBase, projBase, dgEff, preProjOut, tangentOut: untyped) =
+  block:
+    let dgEffp = dgEff.addr
+    let preProjOutp = preProjOut.addr
+    let tangentOutp = tangentOut.addr
+    let sc = pairStageScales(hsp[], stage)
+    primePairStageForwardShifts(hsp[], stage)
+    threads:
+      forPairs(mu, nu):
+        preProjOutp[][mu,nu] := sc.ma * dgEffp[][mu]
+        when stage == psL1:
+          symStapleJVP(preProjOutp[][mu,nu], sc.alp,
+                       hsp[].state.gf[nu], hsp[].state.gf[mu],
+                       hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                       tangentSrc[nu], tangentSrc[mu],
+                       shiftedTangents[nu][mu], shiftedTangents[mu][nu],
+                       hsp[].state.tm1, hsp[].state.sm1[nu])
+          threadBarrier()
+        else:
+          forThird(mu, nu, a, b):
+            let pl1 = pairSrc[a,b]
+            let pl2 = pairSrc[mu,b]
+            let dpl1 = tangentSrc[a,b]
+            let dpl2 = tangentSrc[mu,b]
+            threadBarrier()
+            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+            discard shiftedTangents[mu][nu][a][0] ^*! dpl1
+            discard shiftedTangents[mu][nu][a][1] ^*! dpl2
+            threadBarrier()
+            symStapleJVP(preProjOutp[][mu,nu], sc.alp,
+                         pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                         dpl1, dpl2,
+                         shiftedTangents[mu][nu][a][0], shiftedTangents[mu][nu][a][1],
+                         hsp[].state.tm1, hsp[].state.sm1[a])
+            threadBarrier()
+        tangentOutp[][mu,nu].projJVP(projBase[mu,nu], preProjBase[mu,nu], preProjOutp[][mu,nu])
+
+template hypPairStageJVPL1Ptr(hsp, tangentSrc, shiftedTangents,
+                              preProjBase, projBase, dgEff,
+                              preProjOut, tangentOut: untyped) =
+  hypPairStageJVPPtr(psL1, hsp, hsp[].state.l1x, tangentSrc, shiftedTangents,
+                     preProjBase, projBase, dgEff, preProjOut, tangentOut)
+
+template hypPairStageJVPL2Ptr(hsp, pairSrc, tangentSrc, shiftedTangents,
+                              preProjBase, projBase, dgEff,
+                              preProjOut, tangentOut: untyped) =
+  hypPairStageJVPPtr(psL2, hsp, pairSrc, tangentSrc, shiftedTangents,
+                     preProjBase, projBase, dgEff, preProjOut, tangentOut)
+
+template hypPairStageJVPL1*(hs, tangentSrc, shiftedTangents,
+                            preProjBase, projBase, dgEff,
+                            preProjOut, tangentOut: untyped) =
+  hypPairStageJVPL1Ptr(hs.addr, tangentSrc, shiftedTangents,
+                       preProjBase, projBase, dgEff, preProjOut, tangentOut)
+
+template hypPairStageJVPL2*(hs, pairSrc, tangentSrc, shiftedTangents,
+                            preProjBase, projBase, dgEff,
+                            preProjOut, tangentOut: untyped) =
+  hypPairStageJVPL2Ptr(hs.addr, pairSrc, tangentSrc, shiftedTangents,
+                       preProjBase, projBase, dgEff, preProjOut, tangentOut)
+
+template hypPairStageStapleVJP(stage, hs, pairSrc, chainIn, dst: untyped) =
+  block:
+    let hsp = hs.addr
+    threads:
+      forPairs(mu, nu):
+        when stage == psL1:
+          discard hsp[].kernel.chainShift[nu] ^* chainIn[mu,nu]
+          symStapleVJP(dst[nu], dst[mu],
+                       hsp[].state.gf[nu], hsp[].state.gf[mu],
+                       hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                       chainIn[mu,nu], hsp[].kernel.chainShift[nu],
+                       hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+          threadBarrier()
+        else:
+          forThird(mu, nu, a, b):
+            let pl1 = pairSrc[a,b]
+            let pl2 = pairSrc[mu,b]
+            threadBarrier()
+            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+            discard hsp[].kernel.chainShift[a] ^*! chainIn[mu,nu]
+            threadBarrier()
+            symStapleVJP(dst[a,b], dst[mu,b],
+                         pl1, pl2,
+                         hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                         chainIn[mu,nu], hsp[].kernel.chainShift[a],
+                         hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
+            threadBarrier()
 
 proc hypPairStageStapleVJPL1*(hs: var HypSmear, chainIn: auto; dst: auto) =
-  let hsp = hs.addr
-  threads:
-    forPairs(mu, nu):
-      discard hsp[].work.chainShift[nu] ^* chainIn[mu,nu]
-      symStapleVJP(dst[nu], dst[mu],
-                   hsp[].state.gf[nu], hsp[].state.gf[mu],
-                   hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                   chainIn[mu,nu], hsp[].work.chainShift[nu],
-                   hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
-      threadBarrier()
+  hs.ensureKernelScratch()
+  hypPairStageStapleVJP(psL1, hs, hs.state.l1x, chainIn, dst)
 
 proc hypPairStageStapleVJPL2*(hs: var HypSmear, pairSrc, chainIn: auto;
                               dst: auto) =
-  let hsp = hs.addr
-  threads:
-    forPairs(mu, nu):
-      forThird(mu, nu, a, b):
-        let pl1 = pairSrc[a,b]
-        let pl2 = pairSrc[mu,b]
-        threadBarrier()
-        discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-        discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-        discard hsp[].work.chainShift[a] ^*! chainIn[mu,nu]
-        threadBarrier()
-        symStapleVJP(dst[a,b], dst[mu,b],
-                     pl1, pl2,
-                     hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                     chainIn[mu,nu], hsp[].work.chainShift[a],
-                     hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
-        threadBarrier()
+  hs.ensureKernelScratch()
+  hypPairStageStapleVJP(psL2, hs, pairSrc, chainIn, dst)
+
+template hypPairStageChainVJP(stage, hs, pairSrc, seedBar, dst: untyped) =
+  block:
+    let hsp = hs.addr
+    threads:
+      forPairs(mu, nu):
+        when stage == psL1:
+          symStapleVJPChain(dst[mu,nu],
+                            hsp[].state.gf[nu], hsp[].state.gf[mu],
+                            hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                            seedBar[nu], seedBar[mu],
+                            hsp[].kernel.chainShift[nu], hsp[].kernel.seedShift[mu],
+                            hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu])
+          threadBarrier()
+        else:
+          forThird(mu, nu, a, b):
+            let pl1 = pairSrc[a,b]
+            let pl2 = pairSrc[mu,b]
+            threadBarrier()
+            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+            threadBarrier()
+            symStapleVJPChain(dst[mu,nu],
+                              pl1, pl2,
+                              hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                              seedBar[a,b], seedBar[mu,b],
+                              hsp[].kernel.chainShift[a], hsp[].kernel.seedShift[mu],
+                              hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[a])
+            threadBarrier()
 
 proc hypPairStageChainVJPL1*(hs: var HypSmear, seedBar: auto; dst: auto) =
-  let hsp = hs.addr
-  threads:
-    forPairs(mu, nu):
-      symStapleVJPChain(dst[mu,nu],
-                        hsp[].state.gf[nu], hsp[].state.gf[mu],
-                        hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                        seedBar[nu], seedBar[mu],
-                        hsp[].work.chainShift[nu], hsp[].work.seedShift[mu],
-                        hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu])
-      threadBarrier()
+  hs.ensureKernelScratch()
+  hypPairStageChainVJP(psL1, hs, hs.state.l1x, seedBar, dst)
 
 proc hypPairStageChainVJPL2*(hs: var HypSmear, pairSrc, seedBar: auto;
                              dst: auto) =
-  let hsp = hs.addr
-  threads:
-    forPairs(mu, nu):
-      forThird(mu, nu, a, b):
-        let pl1 = pairSrc[a,b]
-        let pl2 = pairSrc[mu,b]
-        threadBarrier()
-        discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-        discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-        threadBarrier()
-        symStapleVJPChain(dst[mu,nu],
-                          pl1, pl2,
-                          hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                          seedBar[a,b], seedBar[mu,b],
-                          hsp[].work.chainShift[a], hsp[].work.seedShift[mu],
-                          hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a])
-        threadBarrier()
+  hs.ensureKernelScratch()
+  hypPairStageChainVJP(psL2, hs, pairSrc, seedBar, dst)
 
 template accumulateAndScaleGauge(dst, src, ma, alp: auto) =
   threads:
@@ -924,107 +1042,113 @@ template applyPairProjectionHvpPhase(chainBar, dChainBar, projected, xfield,
   applyProjectionHVP(chainBar, dChainBar, projected, xfield, preProjChain, tangent)
   accumulateAndScalePairs(derivHvp, chainBar, ma, alp)
 
-proc hypPairStageHVPL1*(hs: var HypSmear, tangentSrc, chainSrc, dChainIn: auto;
-                        dst: auto) =
+template hypPairStageHVP(stage, hs, pairSrc, tangentSrc, chainSrc, dChainIn, dst: untyped) =
   block:
     let hsp = hs.addr
-    let lo = hsp[].state.gf[0].l
-    type Fld = typeof(hsp[].state.gf[0])
-    var shiftedPairTangents: array[4, array[4, array[2, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]
-    var shiftedChainTangents: array[4, array[4, Shifter[Fld,type(hsp[].state.gf[0][0])]]]
-    forPairs(mu, nu):
-      shiftedPairTangents[mu][nu][0] = newShifter(tangentSrc[nu], mu, 1)
-      shiftedPairTangents[mu][nu][1] = newShifter(tangentSrc[mu], nu, 1)
-      shiftedChainTangents[mu][nu] = newShifter(dChainIn[mu,nu], nu, 1)
-    var acc1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-    var acc2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+    let tangentSrcp = tangentSrc.addr
+    when stage == psL1:
+      let shiftedPairTangentsp = hsp[].hvp.hvpL1ShiftedPairTangents.addr
+      let shiftedChainTangentsp = hsp[].hvp.hvpL1ShiftedChainTangents.addr
+      let acc1p = hsp[].hvp.hvpL1Acc1.addr
+      let acc2p = hsp[].hvp.hvpL1Acc2.addr
 
-    threads:
-      forPairs(mu, nu):
-        discard hsp[].work.chainShift[nu] ^* chainSrc[mu,nu]
-        discard shiftedPairTangents[mu][nu][0] ^*! tangentSrc[nu]
-        discard shiftedPairTangents[mu][nu][1] ^*! tangentSrc[mu]
-        discard shiftedChainTangents[mu][nu] ^*! dChainIn[mu,nu]
-        symStapleHVP(dst[nu], dst[mu], acc1[mu,nu], acc2[mu,nu],
-                     hsp[].state.gf[nu], hsp[].state.gf[mu],
-                     hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                     chainSrc[mu,nu], hsp[].work.chainShift[nu],
-                     tangentSrc[nu], tangentSrc[mu], dChainIn[mu,nu],
-                     shiftedPairTangents[mu][nu][0], shiftedPairTangents[mu][nu][1],
-                     shiftedChainTangents[mu][nu],
-                     hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
-        threadBarrier()
+      threads:
+        forPairs(mu, nu):
+          discard hsp[].kernel.chainShift[nu] ^* chainSrc[mu,nu]
+          discard shiftedPairTangentsp[][mu][nu][0] ^*! tangentSrcp[][nu]
+          discard shiftedPairTangentsp[][mu][nu][1] ^*! tangentSrcp[][mu]
+          discard shiftedChainTangentsp[][mu][nu] ^*! dChainIn[mu,nu]
+          symStapleHVP(dst[nu], dst[mu], acc1p[][mu,nu], acc2p[][mu,nu],
+                       hsp[].state.gf[nu], hsp[].state.gf[mu],
+                       hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                       chainSrc[mu,nu], hsp[].kernel.chainShift[nu],
+                       tangentSrcp[][nu], tangentSrcp[][mu], dChainIn[mu,nu],
+                       shiftedPairTangentsp[][mu][nu][0], shiftedPairTangentsp[][mu][nu][1],
+                       shiftedChainTangentsp[][mu][nu],
+                       hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+          threadBarrier()
+    else:
+      let shiftedPairTangentsp = hsp[].hvp.hvpL2ShiftedPairTangents.addr
+      let shiftedChainTangentsp = hsp[].hvp.hvpL2ShiftedChainTangents.addr
+      let acc1p = hsp[].hvp.hvpL2Acc1.addr
+      let acc2p = hsp[].hvp.hvpL2Acc2.addr
 
-proc hypPairStageHVPL2*(hs: var HypSmear, pairSrc, tangentSrc, chainSrc, dChainIn: auto;
+      threads:
+        forPairs(mu, nu):
+          forThird(mu, nu, a, b):
+            let pl1 = pairSrc[a,b]
+            let pl2 = pairSrc[mu,b]
+            threadBarrier()
+            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+            discard hsp[].kernel.chainShift[a] ^*! chainSrc[mu,nu]
+            discard shiftedPairTangentsp[][mu][nu][a][0] ^*! tangentSrcp[][a,b]
+            discard shiftedPairTangentsp[][mu][nu][a][1] ^*! tangentSrcp[][mu,b]
+            discard shiftedChainTangentsp[][mu][nu][a] ^*! dChainIn[mu,nu]
+            threadBarrier()
+            symStapleHVP(dst[a,b], dst[mu,b],
+                         acc1p[][mu][nu][a], acc2p[][mu][nu][a],
+                         pl1, pl2,
+                         hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                         chainSrc[mu,nu], hsp[].kernel.chainShift[a],
+                         tangentSrcp[][a,b], tangentSrcp[][mu,b], dChainIn[mu,nu],
+                         shiftedPairTangentsp[][mu][nu][a][0], shiftedPairTangentsp[][mu][nu][a][1],
+                         shiftedChainTangentsp[][mu][nu][a],
+                         hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
+            threadBarrier()
+
+proc hypPairStageHVPL1*(hs: var HypSmear, tangentSrc, chainSrc, dChainIn: auto;
                         dst: auto) =
-  block:
-    let hsp = hs.addr
-    let lo = hsp[].state.gf[0].l
-    type Fld = typeof(hsp[].state.gf[0])
-    var shiftedPairTangents: array[4, array[4, array[4, array[2, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]]
-    var shiftedChainTangents: array[4, array[4, array[4, Shifter[Fld,type(hsp[].state.gf[0][0])]]]]
-    forPairs(mu, nu):
-      forThird(mu, nu, a, b):
-        shiftedPairTangents[mu][nu][a][0] = newShifter(tangentSrc[a,b], mu, 1)
-        shiftedPairTangents[mu][nu][a][1] = newShifter(tangentSrc[mu,b], a, 1)
-        shiftedChainTangents[mu][nu][a] = newShifter(dChainIn[mu,nu], a, 1)
-    var acc1: array[4, array[4, array[4, Fld]]]
-    var acc2: array[4, array[4, array[4, Fld]]]
-    forPairs(mu, nu):
-      forThird(mu, nu, a, b):
-        acc1[mu][nu][a] = lo.newField(type(hsp[].state.gf[0][0]))
-        acc2[mu][nu][a] = lo.newField(type(hsp[].state.gf[0][0]))
+  hs.ensureHvpScratch()
+  hypPairStageHVP(psL1, hs, hs.state.l1x, tangentSrc, chainSrc, dChainIn, dst)
 
-    threads:
-      forPairs(mu, nu):
-        forThird(mu, nu, a, b):
-          let pl1 = pairSrc[a,b]
-          let pl2 = pairSrc[mu,b]
-          threadBarrier()
-          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-          discard hsp[].work.chainShift[a] ^*! chainSrc[mu,nu]
-          discard shiftedPairTangents[mu][nu][a][0] ^*! tangentSrc[a,b]
-          discard shiftedPairTangents[mu][nu][a][1] ^*! tangentSrc[mu,b]
-          discard shiftedChainTangents[mu][nu][a] ^*! dChainIn[mu,nu]
-          threadBarrier()
-          symStapleHVP(dst[a,b], dst[mu,b],
-                       acc1[mu][nu][a], acc2[mu][nu][a],
-                       pl1, pl2,
-                       hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                       chainSrc[mu,nu], hsp[].work.chainShift[a],
-                       tangentSrc[a,b], tangentSrc[mu,b], dChainIn[mu,nu],
-                       shiftedPairTangents[mu][nu][a][0], shiftedPairTangents[mu][nu][a][1],
-                       shiftedChainTangents[mu][nu][a],
-                       hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
-          threadBarrier()
+proc hypPairStageHVPL2*(hs: var HypSmear, pairSrc, tangentSrc, chainSrc, dChainIn: auto;
+                        dst: auto) =
+  hs.ensureHvpScratch()
+  hypPairStageHVP(psL2, hs, pairSrc, tangentSrc, chainSrc, dChainIn, dst)
 
-proc hypPairStageHVPVJPL1*(hs: var HypSmear, chainSrc, seedBar,
-                           projected, xfield, preProjChain: auto;
-                           gaugeBarOut, chainBar, nextChainBar: auto) =
+template hypPairStageHVPVJP(stage, hs, pairSrc, chainSrc, seedBar,
+                            projected, xfield, preProjChain,
+                            pairBarOut, chainBar, nextChainBar: untyped) =
   block:
     let hsp = hs.addr
-    let sc = pairStageScalesL1(hsp[])
-    let lo = hsp[].state.gf[0].l
-    type Fld = typeof(hsp[].state.gf[0])
-    var dcbar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+    let sc = pairStageScales(hsp[], stage)
+    let dcbarp = hsp[].hvpAdjoint.hvpVjpDcbar.addr
     threads:
       forPairs(mu, nu):
-        dcbar[mu,nu] := 0
+        dcbarp[][mu,nu] := 0
 
     threads:
       forPairs(mu, nu):
-        discard hsp[].work.chainShift[nu] ^* chainSrc[mu,nu]
-        symStapleHVPVJP(gaugeBarOut[nu], gaugeBarOut[mu], dcbar[mu,nu],
-                        hsp[].state.gf[nu], hsp[].state.gf[mu],
-                        hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                        chainSrc[mu,nu], hsp[].work.chainShift[nu],
-                        seedBar[nu], seedBar[mu],
-                        hsp[].work.seedShift[nu], hsp[].work.seedShift[mu],
-                        hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
-        threadBarrier()
+        when stage == psL1:
+          discard hsp[].kernel.chainShift[nu] ^* chainSrc[mu,nu]
+          symStapleHVPVJP(pairBarOut[nu], pairBarOut[mu], dcbarp[][mu,nu],
+                          hsp[].state.gf[nu], hsp[].state.gf[mu],
+                          hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                          chainSrc[mu,nu], hsp[].kernel.chainShift[nu],
+                          seedBar[nu], seedBar[mu],
+                          hsp[].kernel.seedShift[nu], hsp[].kernel.seedShift[mu],
+                          hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+          threadBarrier()
+        else:
+          forThird(mu, nu, a, b):
+            let pl1 = pairSrc[a,b]
+            let pl2 = pairSrc[mu,b]
+            threadBarrier()
+            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+            discard hsp[].kernel.chainShift[a] ^*! chainSrc[mu,nu]
+            threadBarrier()
+            symStapleHVPVJP(pairBarOut[a,b], pairBarOut[mu,b], dcbarp[][mu,nu],
+                            pl1, pl2,
+                            hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                            chainSrc[mu,nu], hsp[].kernel.chainShift[a],
+                            seedBar[a,b], seedBar[mu,b],
+                            hsp[].kernel.seedShift[a], hsp[].kernel.seedShift[mu],
+                            hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
+            threadBarrier()
 
-    addScaledPairs(chainBar, dcbar, sc.alp)
+    addScaledPairs(chainBar, dcbarp[], sc.alp)
 
     threads:
       forPairs(mu, nu):
@@ -1033,87 +1157,65 @@ proc hypPairStageHVPVJPL1*(hs: var HypSmear, chainSrc, seedBar,
           chainBar[mu,nu]
         )
 
+proc hypPairStageHVPVJPL1*(hs: var HypSmear, chainSrc, seedBar,
+                           projected, xfield, preProjChain: auto;
+                           gaugeBarOut, chainBar, nextChainBar: auto) =
+  hs.ensureKernelScratch()
+  hs.ensureHvpAdjointScratch()
+  hypPairStageHVPVJP(psL1, hs, hs.state.l1x, chainSrc, seedBar,
+                     projected, xfield, preProjChain,
+                     gaugeBarOut, chainBar, nextChainBar)
+
 proc hypPairStageHVPVJPL2*(hs: var HypSmear, pairSrc, chainSrc,
                            seedBar, projected, xfield, preProjChain: auto;
                            pairBarOut, chainBar, nextChainBar: auto) =
+  hs.ensureKernelScratch()
+  hs.ensureHvpAdjointScratch()
+  hypPairStageHVPVJP(psL2, hs, pairSrc, chainSrc, seedBar,
+                     projected, xfield, preProjChain,
+                     pairBarOut, chainBar, nextChainBar)
+
+template hypPairStageJVPVJP(stage, hs, pairSrc, tangentXBar, pairBarOut, dgEffbar: untyped) =
   block:
     let hsp = hs.addr
-    let sc = pairStageScalesL2(hsp[])
-    let lo = hsp[].state.gf[0].l
-    type Fld = typeof(hsp[].state.gf[0])
-    var dcbar = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+    let sc = pairStageScales(hsp[], stage)
     threads:
       forPairs(mu, nu):
-        dcbar[mu,nu] := 0
+        dgEffbar[mu] += sc.ma * tangentXBar[mu,nu]
 
     threads:
       forPairs(mu, nu):
-        forThird(mu, nu, a, b):
-          let pl1 = pairSrc[a,b]
-          let pl2 = pairSrc[mu,b]
-          threadBarrier()
-          discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-          discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-          discard hsp[].work.chainShift[a] ^*! chainSrc[mu,nu]
+        when stage == psL1:
+          symStapleJVPVJP(dgEffbar[nu], dgEffbar[mu], sc.alp,
+                          hsp[].state.gf[nu], hsp[].state.gf[mu],
+                          hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
+                          tangentXBar[mu,nu], hsp[].kernel.seedShift[nu],
+                          hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
           threadBarrier()
-          symStapleHVPVJP(pairBarOut[a,b], pairBarOut[mu,b], dcbar[mu,nu],
-                          pl1, pl2,
-                          hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                          chainSrc[mu,nu], hsp[].work.chainShift[a],
-                          seedBar[a,b], seedBar[mu,b],
-                          hsp[].work.seedShift[a], hsp[].work.seedShift[mu],
-                          hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
-          threadBarrier()
-
-    addScaledPairs(chainBar, dcbar, sc.alp)
-
-    threads:
-      forPairs(mu, nu):
-        nextChainBar[mu,nu].projHVPVJP_dc(
-          projected[mu,nu], xfield[mu,nu], preProjChain[mu,nu],
-          chainBar[mu,nu]
-        )
+        else:
+          forThird(mu, nu, a, b):
+            let pl1 = pairSrc[a,b]
+            let pl2 = pairSrc[mu,b]
+            threadBarrier()
+            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
+            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
+            threadBarrier()
+            symStapleJVPVJP(pairBarOut[a,b], pairBarOut[mu,b], sc.alp,
+                            pl1, pl2,
+                            hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
+                            tangentXBar[mu,nu], hsp[].kernel.seedShift[a],
+                            hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
+            threadBarrier()
 
 proc hypPairStageJVPVJPL1*(hs: var HypSmear, tangentXBar: auto;
                            dgEffbar: auto) =
-  let hsp = hs.addr
-  let sc = pairStageScalesL1(hsp[])
-  threads:
-    forPairs(mu, nu):
-      dgEffbar[mu] += sc.ma * tangentXBar[mu,nu]
-
-  threads:
-    forPairs(mu, nu):
-      symStapleJVPVJP(dgEffbar[nu], dgEffbar[mu], sc.alp,
-                      hsp[].state.gf[nu], hsp[].state.gf[mu],
-                      hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                      tangentXBar[mu,nu], hsp[].work.seedShift[nu],
-                      hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
-      threadBarrier()
+  hs.ensureKernelScratch()
+  hypPairStageJVPVJP(psL1, hs, hs.state.l1x, tangentXBar, hs.state.l1x, dgEffbar)
 
 proc hypPairStageJVPVJPL2*(hs: var HypSmear, pairSrc, tangentXBar: auto;
                            pairBarOut, dgEffbar: auto) =
-  let hsp = hs.addr
-  let sc = pairStageScalesL2(hsp[])
-  threads:
-    forPairs(mu, nu):
-      dgEffbar[mu] += sc.ma * tangentXBar[mu,nu]
-
-  threads:
-    forPairs(mu, nu):
-      forThird(mu, nu, a, b):
-        let pl1 = pairSrc[a,b]
-        let pl2 = pairSrc[mu,b]
-        threadBarrier()
-        discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-        discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-        threadBarrier()
-        symStapleJVPVJP(pairBarOut[a,b], pairBarOut[mu,b], sc.alp,
-                        pl1, pl2,
-                        hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                        tangentXBar[mu,nu], hsp[].work.seedShift[a],
-                        hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
-        threadBarrier()
+  hs.ensureKernelScratch()
+  hypPairStageJVPVJP(psL2, hs, pairSrc, tangentXBar, pairBarOut, dgEffbar)
 
 ## Final output-stage operator family built from L2 pair fields.
 proc hypOutputStage*(hs: var HypSmear, l2: auto; flx, fl: auto) =
@@ -1130,13 +1232,14 @@ proc hypOutputStage*(hs: var HypSmear, l2: auto; flx, fl: auto) =
         let pl2 = l2[mu,nu]
         symStaple(flx[mu], sc.alp, pl1, pl2,
                   hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
-                  hsp[].work.tm1, hsp[].state.sm1[nu])
+                  hsp[].state.tm1, hsp[].state.sm1[nu])
         threadBarrier()
       fl[mu].proj flx[mu]
 
-proc hypOutputStageJVP*(hs: var HypSmear, l2, dl2, dsl2, dgEff: auto;
-                        dflx: auto) =
-  let hsp = hs.addr
+template hypOutputStageJVPPtr(hsp, l2, dl2, dsl2, dgEff, dflx: untyped) =
+  let dsl2p = dsl2.addr
+  let dgEffp = dgEff.addr
+  let dflxp = dflx.addr
   let sc = outputStageScales(hsp[])
   threads:
     forPairs(mu, nu):
@@ -1144,65 +1247,51 @@ proc hypOutputStageJVP*(hs: var HypSmear, l2, dl2, dsl2, dgEff: auto;
 
   threads:
     for mu in 0..<4:
-      dflx[mu] := sc.ma * dgEff[mu]
+      dflxp[][mu] := sc.ma * dgEffp[][mu]
       forNu(mu, nu):
         let pl1 = l2[nu,mu]
         let pl2 = l2[mu,nu]
         let dpl1 = dl2[nu,mu]
         let dpl2 = dl2[mu,nu]
-        symStapleJVP(dflx[mu], sc.alp,
+        symStapleJVP(dflxp[][mu], sc.alp,
                      pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
-                     dpl1, dpl2, dsl2[nu][mu], dsl2[mu][nu],
-                     hsp[].work.tm1, hsp[].state.sm1[nu])
+                     dpl1, dpl2, dsl2p[][nu][mu], dsl2p[][mu][nu],
+                     hsp[].state.tm1, hsp[].state.sm1[nu])
         threadBarrier()
 
-proc buildTangentState[L,F,T](hs: var HypSmear[L,F,T], dg: auto): auto =
+template hypOutputStageJVP*(hs, l2, dl2, dsl2, dgEff, dflx: untyped) =
+  hypOutputStageJVPPtr(hs.addr, l2, dl2, dsl2, dgEff, dflx)
+
+proc buildTangentState[L,F,T](hs: var HypSmear[L,F,T], levels: auto, dg: auto) =
   ## Build the shared forward tangent state used by `smearJVP` and `smearHVP`.
-  var l1: type(hs.state.l1x)
-  var l2: type(hs.state.l2x)
-  initProjectedLevels(hs, l1, l2)
+  hs.ensureTangentScratch()
+  let hsp = hs.addr
 
-  let lo = hs.state.gf[0].l
-  type Fld = typeof(hs.state.gf[0])
-  let dgEff = buildGaugeTangent(hs.state.gf, dg)
-  let ds1 = initShiftedTangents(dgEff)
+  let dgEffp = hs.tangent.tangentDgEff.addr
+  buildGaugeTangent(dgEffp[], hsp[].state.gf, dg)
+  let ds1p = hs.tangent.tangentDs1.addr
+  primeShiftedTangentsPtr(ds1p, dgEffp)
 
-  var dl1x = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dl2x = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dflx = newFieldArray(lo, Fld, 4)
-  var dl1 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
-  var dl2 = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+  let dl1xp = hs.tangent.tangentDl1x.addr
+  let dl2xp = hs.tangent.tangentDl2x.addr
+  let dl1p = hs.tangent.tangentDl1.addr
+  let dl2p = hs.tangent.tangentDl2.addr
+  let dsl1L2p = hs.tangent.tangentDsl1L2.addr
+  let dsl2p = hs.tangent.tangentDsl2.addr
+  let dflxp = hs.tangent.tangentDflx.addr
+  clearTangentWorkspace(dflxp[], dl1xp[], dl2xp[], dl1p[], dl2p[])
 
-  clearTangentWorkspace(dflx, dl1x, dl2x, dl1, dl2)
+  hypPairStageJVPL1Ptr(hsp, dgEffp[], ds1p[], hsp[].state.l1x, levels.l1,
+                       dgEffp[], dl1xp[], dl1p[])
 
-  hypPairStageJVPL1(hs, dgEff, ds1, hs.state.l1x, l1, dgEff, dl1x, dl1)
+  hypPairStageJVPL2Ptr(hsp, levels.l1, dl1p[], dsl1L2p[],
+                       hsp[].state.l2x, levels.l2, dgEffp[], dl2xp[], dl2p[])
 
-  var dsl1_l2: array[4, array[4, array[4, array[2, Shifter[Fld,type(hs.state.gf[0][0])]]]]]
-  forPairs(mu, nu):
-    forThird(mu, nu, a, b):
-      dsl1_l2[mu][nu][a][0] = newShifter(dl1[a,b], mu, 1)
-      dsl1_l2[mu][nu][a][1] = newShifter(dl1[mu,b], a, 1)
-
-  hypPairStageJVPL2(hs, l1, dl1, dsl1_l2, hs.state.l2x, l2, dgEff, dl2x, dl2)
-
-  var dsl2: array[4,array[4,Shifter[Fld,type(hs.state.gf[0][0])]]]
-  forPairs(mu, nu):
-    dsl2[mu][nu] = newShifter(dl2[mu,nu], nu, 1)
   threads:
     forPairs(mu, nu):
-      discard dsl2[mu][nu] ^*! dl2[mu,nu]
-
-  hypOutputStageJVP(hs, l2, dl2, dsl2, dgEff, dflx)
-
-  HypTangentState[typeof(dgEff), typeof(dflx), typeof(dl1x), typeof(dsl2)](
-    dgEff: dgEff,
-    dl1x: dl1x,
-    dl1: dl1,
-    dl2x: dl2x,
-    dl2: dl2,
-    dflx: dflx,
-    dsl2: dsl2,
-  )
+      discard dsl2p[][mu][nu] ^*! dl2p[][mu,nu]
+
+  hypOutputStageJVPPtr(hsp, levels.l2, dl2p[], dsl2p[], dgEffp[], dflxp[])
 
 template accumulateProjectionAdjoint(dxbar, x, chain0, tangentBar, hvpBar: auto) =
   threads:
@@ -1219,33 +1308,37 @@ template accumulateProjectionAdjoint(dxbar, x, chain0, tangentBar, hvpBar: auto)
         tmp.projectUHVPVJP_dx(x[mu,nu][i], chain0[mu,nu][i], hvpBar[mu,nu][i])
         dxbar[mu,nu][i] += tmp
 
-template applyPairProjectionChainAdjoint(chainBar, projected, xfield: auto) =
-  let lo = projected[0,1].l
-  type Fld = typeof(projected[0,1])
-  var chainBarTmp = newFieldArray2(lo, Fld, [4,4], mu!=nu)
+template applyPairProjectionChainAdjoint(hs, chainBar, projected, xfield: auto) =
+  let hsp = hs.addr
+  let chainBarp = chainBar.addr
+  let chainBarTmpp = hsp[].chainAdjoint.pairProjectionTmp.addr
   threads:
     forPairs(mu, nu):
-      chainBarTmp[mu,nu] := chainBar[mu,nu]
-      chainBar[mu,nu] := 0
-      chainBar[mu,nu].projVJPChain(projected[mu,nu], xfield[mu,nu], chainBarTmp[mu,nu])
+      chainBarTmpp[][mu,nu] := chainBarp[][mu,nu]
+      chainBarp[][mu,nu] := 0
+      chainBarp[][mu,nu].projVJPChain(projected[mu,nu], xfield[mu,nu], chainBarTmpp[][mu,nu])
 
 template applyProjectionHVP(dst, dchain0, u, x, chain0, dx: auto) =
   ## Apply the projection HVP for a full level while preserving the incoming
   ## chain tangent in `dchain0`.
+  let dxp = dx.addr
   threads:
     forPairs(mu, nu):
       dchain0[mu,nu] := dst[mu,nu]
       dst[mu,nu] := 0
       dst[mu,nu].projHVPu(u[mu,nu], x[mu,nu], chain0[mu,nu],
-                          dx[mu,nu], dchain0[mu,nu])
+                          dxp[][mu,nu], dchain0[mu,nu])
 
-template applyOutputProjectionHVP(dst, x, chain0, dx, dchain: auto) =
+template applyOutputProjectionHVPPtr(dst, x, chain0, dxp, dchain: auto) =
   threads:
     for mu in 0..<4:
       if dchain.len > 0:
-        dst[mu].projHVP(x[mu], chain0[mu], dx[mu], dchain[mu])
+        dst[mu].projHVP(x[mu], chain0[mu], dxp[][mu], dchain[mu])
       else:
-        dst[mu].projHVP(x[mu], chain0[mu], dx[mu])
+        dst[mu].projHVP(x[mu], chain0[mu], dxp[][mu])
+
+template applyOutputProjectionHVP(dst, x, chain0, dx, dchain: auto) =
+  applyOutputProjectionHVPPtr(dst, x, chain0, dx.addr, dchain)
 
 template seedSmearHVPAdjoints(dfl1bar, dfl2bar, dfcbar, derivbar,
                               ma1, ma2, ma3: auto) =
@@ -1256,30 +1349,27 @@ template seedSmearHVPAdjoints(dfl1bar, dfl2bar, dfcbar, derivbar,
         dfl1bar[mu,nu] += ma1 * derivbar[mu]
         dfl2bar[mu,nu] += ma2 * derivbar[mu]
 
-template buildReverseState(hsp, chain, deriv: untyped; accumulateDirect: static bool) =
+template buildReverseState(hsp, levels, chain, deriv: untyped; accumulateDirect: static bool) =
   ## Build the reverse HYP chain state, optionally accumulating the direct
   ## ma3/ma2/ma1 contributions into `deriv`.
   let sc = hsp[].scaleFactors
-  var l1: type(hsp.state.l1x)
-  var l2: type(hsp.state.l2x)
-  initProjectedLevels(hsp[], l1, l2)
 
-  clearReverseChains(hsp.work.outputChain, hsp.work.level1Chain, hsp.work.level2Chain)
+  clearReverseChains(hsp[].reverse.outputChain, hsp[].reverse.level1Chain, hsp[].reverse.level2Chain)
 
   threads:
     for mu in 0..<4:
-      hsp.work.outputChain[mu].projVJP(hsp.state.flx[mu], chain[mu])
+      hsp[].reverse.outputChain[mu].projVJP(hsp[].state.flx[mu], chain[mu])
       when accumulateDirect:
-        deriv[mu] := sc.ma3 * hsp.work.outputChain[mu]
-      hsp.work.outputChain[mu] *= sc.alp3
+        deriv[mu] := sc.ma3 * hsp[].reverse.outputChain[mu]
+      hsp[].reverse.outputChain[mu] *= sc.alp3
 
-  hypOutputStageStapleVJP(hsp[], l2, hsp[].work.outputChain, hsp[].work.level2Chain)
-  projectAndScalePairChain(hsp.work.level2Chain, l2, hsp.state.l2x,
-                           hsp.work.preProjLevel2Chain, sc.alp2, deriv, sc.ma2,
+  hypOutputStageStapleVJP(hsp[], levels.l2, hsp[].reverse.outputChain, hsp[].reverse.level2Chain)
+  projectAndScalePairChain(hsp[].reverse.level2Chain, levels.l2, hsp[].state.l2x,
+                           hsp[].reverse.preProjLevel2Chain, sc.alp2, deriv, sc.ma2,
                            accumulateDirect)
-  hypPairStageStapleVJPL2(hsp[], l1, hsp[].work.level2Chain, hsp[].work.level1Chain)
-  projectAndScalePairChain(hsp.work.level1Chain, l1, hsp.state.l1x,
-                           hsp.work.preProjLevel1Chain, sc.alp1, deriv, sc.ma1,
+  hypPairStageStapleVJPL2(hsp[], levels.l1, hsp[].reverse.level2Chain, hsp[].reverse.level1Chain)
+  projectAndScalePairChain(hsp[].reverse.level1Chain, levels.l1, hsp[].state.l1x,
+                           hsp[].reverse.preProjLevel1Chain, sc.alp1, deriv, sc.ma1,
                            accumulateDirect)
 
 proc smear*(hs: var HypSmear, gf: auto, fl: auto) =
@@ -1291,13 +1381,11 @@ proc smear*(hs: var HypSmear, gf: auto, fl: auto) =
     l1x = hs.state.l1x
     l2x = hs.state.l2x
     flx = hs.state.flx
-  var l1: typeof(l1x)
-  var l2: typeof(l2x)
-  initForwardProjectedLevels(hs, l1, l2)
+  var levels = hs.forwardProjectedLevels()
 
-  hypPairStageL1(hs, l1x, l1)
-  hypPairStageL2(hs, l1, l2x, l2)
-  hypOutputStage(hs, l2, flx, fl)
+  hypPairStageL1(hs, l1x, levels.l1)
+  hypPairStageL2(hs, levels.l1, l2x, levels.l2)
+  hypOutputStage(hs, levels.l2, flx, fl)
 
 proc smearVJP*(hs: var HypSmear, deriv: auto, chain: auto) =
   static:
@@ -1305,16 +1393,16 @@ proc smearVJP*(hs: var HypSmear, deriv: auto, chain: auto) =
     doAssert(type(chain[0]) is typeof(hs.state.gf[0]))
   ## Backpropagate derivative through hs.smear
   let hsp = hs.addr
-  buildReverseState(hsp, chain, deriv, true)
-  hypPairStageStapleVJPL1(hsp[], hsp[].work.level1Chain, deriv)
+  hs.ensureKernelScratch()
+  hs.ensureReverseStateScratch()
+  let levels = hs.projectedLevels()
+  buildReverseState(hsp, levels, chain, deriv, true)
+  hypPairStageStapleVJPL1(hsp[], hsp[].reverse.level1Chain, deriv)
 
-proc hypOutputProjectionJVP*(dst: auto; projected, preProj, tangent: auto) =
-  let lo = preProj[0].l
-  var tangentTmp = lo.newGauge
+template hypOutputProjectionJVPPtr(dst, projected, preProj, tangentp: untyped) =
   threads:
     for mu in 0..<4:
-      tangentTmp[mu] := tangent[mu]
-      dst[mu].projJVP(projected[mu], preProj[mu], tangentTmp[mu])
+      dst[mu].projJVP(projected[mu], preProj[mu], tangentp[][mu])
 
 proc smearJVP*[G](hs: var HypSmear, dsg: G, dg: G, sg: G) =
   ## Forward tangent of HYP smearing.
@@ -1333,29 +1421,33 @@ proc smearJVP*[G](hs: var HypSmear, dsg: G, dg: G, sg: G) =
   static:
     doAssert(type(dsg[0]) is typeof(hs.state.gf[0]))
     doAssert(type(dg[0])  is typeof(hs.state.gf[0]))
-  let tangents = hs.buildTangentState(dg)
+  let hsp = hs.addr
+  let levels = hs.projectedLevels()
+  hs.buildTangentState(levels, dg)
 
-  hypOutputProjectionJVP(dsg, sg, hs.state.flx, tangents.dflx)
+  hypOutputProjectionJVPPtr(dsg, sg, hsp.state.flx, hsp[].tangent.tangentDflx.addr)
 
-proc hypOutputStageHVP*(hs: var HypSmear, l2, dl2, dsl2, dOutputChain: auto;
-                        dLevel2Chain: auto) =
+template hypOutputStageHVPPtr(hsp, l2, dl2, dsl2p, dOutputChain, dLevel2Chain: untyped) =
   block:
-    let hsp = hs.addr
-    var scratch = newLevel3HvpScratch(hsp[].state.gf, dOutputChain)
+    let dl2p = dl2.addr
+    let scratchp = hsp[].hvp.level3Hvp.addr
 
     forLevel3Pairs(hsp[], l2, pl1, pl2):
-      discard hsp[].work.chainShift[nu] ^*! hsp[].work.outputChain[mu]
-      discard scratch.shiftedOutputChain[mu][nu] ^*! dOutputChain[mu]
+      discard hsp[].kernel.chainShift[nu] ^*! hsp[].reverse.outputChain[mu]
+      discard scratchp[].shiftedOutputChain[mu][nu] ^*! dOutputChain[mu]
       threadBarrier()
       symStapleHVP(dLevel2Chain[nu,mu], dLevel2Chain[mu,nu],
-                   scratch.acc1[mu,nu], scratch.acc2[mu,nu],
+                   scratchp[].acc1[mu,nu], scratchp[].acc2[mu,nu],
                    pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
-                   hsp[].work.outputChain[mu], hsp[].work.chainShift[nu],
-                   dl2[nu,mu], dl2[mu,nu], dOutputChain[mu],
-                   dsl2[nu][mu], dsl2[mu][nu], scratch.shiftedOutputChain[mu][nu],
-                   hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+                   hsp[].reverse.outputChain[mu], hsp[].kernel.chainShift[nu],
+                   dl2p[][nu,mu], dl2p[][mu,nu], dOutputChain[mu],
+                   dsl2p[][nu][mu], dsl2p[][mu][nu], scratchp[].shiftedOutputChain[mu][nu],
+                   hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
       threadBarrier()
 
+template hypOutputStageHVP*(hs, l2, dl2, dsl2, dOutputChain, dLevel2Chain: untyped) =
+  hypOutputStageHVPPtr(hs.addr, l2, dl2, dsl2, dOutputChain, dLevel2Chain)
+
 proc smearHVP*[G](hs: var HypSmear, dderiv: G, chain: G, dg: G,
                   dchain: G = @[]) =
   ## Second derivative of the uncontracted HYP reverse pass.
@@ -1374,41 +1466,38 @@ proc smearHVP*[G](hs: var HypSmear, dderiv: G, chain: G, dg: G,
     doAssert(type(dg[0])     is typeof(hs.state.gf[0]))
 
   let sc = hs.scaleFactors
-  var l1: type(hs.state.l1x)
-  var l2: type(hs.state.l2x)
-  initProjectedLevels(hs, l1, l2)
+  hs.ensureKernelScratch()
+  hs.ensureReverseStateScratch()
+  hs.ensureHvpScratch()
+  let levels = hs.projectedLevels()
   let hsp = hs.addr
 
   ## Phase 1: analytical forward tangents
-  let tangents = hs.buildTangentState(dg)
-  let dgEff = tangents.dgEff
-  let dl1x = tangents.dl1x
-  let dl1 = tangents.dl1
-  let dl2x = tangents.dl2x
-  let dl2 = tangents.dl2
-  let dflx = tangents.dflx
-  let dsl2 = tangents.dsl2
-
-  var work = newHvpWorkspace(hs.state.gf)
-  clearHvpWorkspace(dderiv, work.dOutputChain, work.dLevel1Chain, work.dLevel2Chain)
+  hs.buildTangentState(levels, dg)
+
+  let hvp = hsp[].hvp
+  clearHvpWorkspace(dderiv, hvp.dOutputChain, hvp.dLevel1Chain, hvp.dLevel2Chain)
 
   ## Phase 2: shared reverse-chain state
-  buildReverseState(hsp, chain, nil, false)
+  buildReverseState(hsp, levels, chain, nil, false)
 
   ## Phase 3: second-order adjoints through the three HYP levels
-  applyOutputProjectionHVP(work.dOutputChain, hsp.state.flx, chain, dflx, dchain)
-  accumulateAndScaleGauge(dderiv, work.dOutputChain, sc.ma3, sc.alp3)
-  hypOutputStageHVP(hsp[], l2, dl2, dsl2, work.dOutputChain, work.dLevel2Chain)
+  applyOutputProjectionHVPPtr(hvp.dOutputChain, hsp.state.flx, chain,
+                              hsp[].tangent.tangentDflx.addr, dchain)
+  accumulateAndScaleGauge(dderiv, hvp.dOutputChain, sc.ma3, sc.alp3)
+  hypOutputStageHVPPtr(hsp, levels.l2, hsp[].tangent.tangentDl2, hsp[].tangent.tangentDsl2.addr,
+                       hvp.dOutputChain, hvp.dLevel2Chain)
 
   # Level 2: projection on l2x and staples built from l1
-  applyPairProjectionHvpPhase(work.dLevel2Chain, work.dPreProjLevel2Chain, l2, hsp.state.l2x,
-                              hsp.work.preProjLevel2Chain, dl2x, dderiv, sc.ma2, sc.alp2)
-  hypPairStageHVPL2(hsp[], l1, dl1, hsp[].work.level2Chain, work.dLevel2Chain, work.dLevel1Chain)
+  applyPairProjectionHvpPhase(hvp.dLevel2Chain, hvp.dPreProjLevel2Chain, levels.l2, hsp.state.l2x,
+                              hsp[].reverse.preProjLevel2Chain, hsp[].tangent.tangentDl2x, dderiv, sc.ma2, sc.alp2)
+  hypPairStageHVPL2(hsp[], levels.l1, hsp[].tangent.tangentDl1,
+                    hsp[].reverse.level2Chain, hvp.dLevel2Chain, hvp.dLevel1Chain)
 
   # Level 1: projection on l1x and staples built directly from gf
-  applyPairProjectionHvpPhase(work.dLevel1Chain, work.dPreProjLevel1Chain, l1, hsp.state.l1x,
-                              hsp.work.preProjLevel1Chain, dl1x, dderiv, sc.ma1, sc.alp1)
-  hypPairStageHVPL1(hsp[], dgEff, hsp[].work.level1Chain, work.dLevel1Chain, dderiv)
+  applyPairProjectionHvpPhase(hvp.dLevel1Chain, hvp.dPreProjLevel1Chain, levels.l1, hsp.state.l1x,
+                              hsp[].reverse.preProjLevel1Chain, hsp[].tangent.tangentDl1x, dderiv, sc.ma1, sc.alp1)
+  hypPairStageHVPL1(hsp[], hsp[].tangent.tangentDgEff, hsp[].reverse.level1Chain, hvp.dLevel1Chain, dderiv)
 
 proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
   ## Adjoint of `smearVJP` with respect to `chain`.
@@ -1420,68 +1509,76 @@ proc smearVJPChain*[G](hs: var HypSmear, chainbar: G, derivbar: G) =
     doAssert(type(derivbar[0]) is typeof(hs.state.gf[0]))
 
   let sc = hs.scaleFactors
-  var l1: type(hs.state.l1x)
-  var l2: type(hs.state.l2x)
-  initProjectedLevels(hs, l1, l2)
+  hs.ensureChainAdjointScratch()
+  let levels = hs.projectedLevels()
   let hsp = hs.addr
 
   # Phase 1: seed the adjoint workspaces
-  var work = newChainAdjointWorkspace(chainbar, hsp.state.gf)
+  clearChainAdjointWorkspace(hsp[].chainAdjoint.outputChainBar, chainbar,
+                             hsp[].chainAdjoint.level1ChainBar, hsp[].chainAdjoint.level2ChainBar)
 
   # Phase 2: backpropagate the Level 1 reverse pair stage
-  hypPairStageChainVJPL1(hsp[], derivbar, work.level1ChainBar)
+  hypPairStageChainVJPL1(hsp[], derivbar, hsp[].chainAdjoint.level1ChainBar)
 
   # Phase 3: apply the Level 1 direct term and projection-chain adjoint
   threads:
     forPairs(mu, nu):
-      work.level1ChainBar[mu,nu] *= sc.alp1
-      work.level1ChainBar[mu,nu] += sc.ma1 * derivbar[mu]
-  applyPairProjectionChainAdjoint(work.level1ChainBar, l1, hsp.state.l1x)
+      hsp[].chainAdjoint.level1ChainBar[mu,nu] *= sc.alp1
+      hsp[].chainAdjoint.level1ChainBar[mu,nu] += sc.ma1 * derivbar[mu]
+  applyPairProjectionChainAdjoint(hsp[], hsp[].chainAdjoint.level1ChainBar, levels.l1, hsp.state.l1x)
 
   # Phase 4: backpropagate the Level 2 reverse pair stage
-  hypPairStageChainVJPL2(hsp[], l1, work.level1ChainBar, work.level2ChainBar)
+  hypPairStageChainVJPL2(hsp[], levels.l1,
+                         hsp[].chainAdjoint.level1ChainBar,
+                         hsp[].chainAdjoint.level2ChainBar)
 
   # Phase 5: apply the Level 2 direct term and projection-chain adjoint
   threads:
     forPairs(mu, nu):
-      work.level2ChainBar[mu,nu] *= sc.alp2
-      work.level2ChainBar[mu,nu] += sc.ma2 * derivbar[mu]
-  applyPairProjectionChainAdjoint(work.level2ChainBar, l2, hsp.state.l2x)
+      hsp[].chainAdjoint.level2ChainBar[mu,nu] *= sc.alp2
+      hsp[].chainAdjoint.level2ChainBar[mu,nu] += sc.ma2 * derivbar[mu]
+  applyPairProjectionChainAdjoint(hsp[], hsp[].chainAdjoint.level2ChainBar, levels.l2, hsp.state.l2x)
 
   # Phase 6: backpropagate the Level 3 reverse pair stage
-  hypOutputStageChainVJP(hsp[], l2, work.level2ChainBar, work.outputChainBar)
+  hypOutputStageChainVJP(hsp[], levels.l2,
+                         hsp[].chainAdjoint.level2ChainBar,
+                         hsp[].chainAdjoint.outputChainBar)
 
   # Phase 7: apply the Level 3 direct term and finish at the output projection
   threads:
     for mu in 0..<4:
-      work.outputChainBar[mu] *= sc.alp3
-      work.outputChainBar[mu] += sc.ma3 * derivbar[mu]
+      hsp[].chainAdjoint.outputChainBar[mu] *= sc.alp3
+      hsp[].chainAdjoint.outputChainBar[mu] += sc.ma3 * derivbar[mu]
   threads:
     for mu in 0..<4:
-      chainbar[mu].projVJPChain(hsp.state.flx[mu], work.outputChainBar[mu])
+      chainbar[mu].projVJPChain(hsp.state.flx[mu], hsp[].chainAdjoint.outputChainBar[mu])
 
 proc hypOutputStageHVPVJP*(hs: var HypSmear, dLevel2ChainBarFromL3, l2: auto;
                            dl2bar, dOutputChainBar: auto) =
+  hs.ensureKernelScratch()
+  hs.ensureHvpAdjointScratch()
   block:
     let hsp = hs.addr
     let sc = outputStageScales(hsp[])
-    var scratch = newLevel3AdjointScratch(hsp[].state.gf)
+    let scratchp = hsp[].hvpAdjoint.level3Adjoint.addr
+    clearLevel3AdjointScratch(scratchp[].dcbar)
 
     forLevel3Pairs(hsp[], l2, pl1, pl2):
-      discard hsp[].work.chainShift[nu] ^*! hsp[].work.outputChain[mu]
+      discard hsp[].kernel.chainShift[nu] ^*! hsp[].reverse.outputChain[mu]
       threadBarrier()
-      symStapleHVPVJP(dl2bar[nu,mu], dl2bar[mu,nu], scratch.dcbar[mu],
+      symStapleHVPVJP(dl2bar[nu,mu], dl2bar[mu,nu], scratchp[].dcbar[mu],
                       pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
-                      hsp[].work.outputChain[mu], hsp[].work.chainShift[nu],
+                      hsp[].reverse.outputChain[mu], hsp[].kernel.chainShift[nu],
                       dLevel2ChainBarFromL3[nu,mu], dLevel2ChainBarFromL3[mu,nu],
-                      hsp[].work.seedShift[nu], hsp[].work.seedShift[mu],
-                      hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+                      hsp[].kernel.seedShift[nu], hsp[].kernel.seedShift[mu],
+                      hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
       threadBarrier()
 
-    addScaledGauge(dOutputChainBar, scratch.dcbar, sc.alp)
+    addScaledGauge(dOutputChainBar, scratchp[].dcbar, sc.alp)
 
 proc hypOutputStageJVPVJP*(hs: var HypSmear, dOutputTangentBar, l2: auto;
                            dgEffbar, dl2bar: auto) =
+  hs.ensureKernelScratch()
   block:
     let hsp = hs.addr
     let sc = outputStageScales(hsp[])
@@ -1492,8 +1589,8 @@ proc hypOutputStageJVPVJP*(hs: var HypSmear, dOutputTangentBar, l2: auto;
     forLevel3Pairs(hsp[], l2, pl1, pl2):
       symStapleJVPVJP(dl2bar[nu,mu], dl2bar[mu,nu], sc.alp,
                       pl1, pl2, hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
-                      dOutputTangentBar[mu], hsp[].work.seedShift[nu],
-                      hsp[].work.tm1, hsp[].work.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
+                      dOutputTangentBar[mu], hsp[].kernel.seedShift[nu],
+                      hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
       threadBarrier()
 
 proc smearHVPVJP*[G](hs: var HypSmear, gbar: G, derivbar: G, chain: G) =
@@ -1508,42 +1605,47 @@ proc smearHVPVJP*[G](hs: var HypSmear, gbar: G, derivbar: G, chain: G) =
     doAssert(type(chain[0]) is typeof(hs.state.gf[0]))
 
   let sc = hs.scaleFactors
-  var l1: type(hs.state.l1x)
-  var l2: type(hs.state.l2x)
-  initProjectedLevels(hs, l1, l2)
+  hs.ensureKernelScratch()
+  hs.ensureReverseStateScratch()
+  hs.ensureHvpAdjointScratch()
+  let levels = hs.projectedLevels()
   let hsp = hs.addr
-  buildReverseState(hsp, chain, nil, false)
+  buildReverseState(hsp, levels, chain, nil, false)
 
-  var work = newHvpAdjointWorkspace(gbar, hsp.state.gf)
+  let adj = hsp[].hvpAdjoint
+  clearHvpAdjointWorkspace(gbar, adj.dflxbar, adj.dfcbar, adj.dgEffbar,
+                           adj.dfl1bar, adj.dfl2bar, adj.dl1bar, adj.dl2bar,
+                           adj.dl1xbar, adj.dl2xbar)
+  clearHvpAdjointIntermediates(adj.dfl1barL2, adj.dfl2barL3)
 
   # Phase 1: seed the adjoints from the output contribution of `smearHVP`
-  seedSmearHVPAdjoints(work.dfl1bar, work.dfl2bar, work.dfcbar, derivbar, sc.ma1, sc.ma2, sc.ma3)
+  seedSmearHVPAdjoints(adj.dfl1bar, adj.dfl2bar, adj.dfcbar, derivbar, sc.ma1, sc.ma2, sc.ma3)
 
   # Phase 2: reverse the Level 1 and Level 2 HVP output paths
-  hypPairStageHVPVJPL1(hsp[], hsp[].work.level1Chain, derivbar,
-                       l1, hsp.state.l1x, hsp.work.preProjLevel1Chain,
-                       work.dgEffbar, work.dfl1bar, work.dfl1barL2)
+  hypPairStageHVPVJPL1(hsp[], hsp[].reverse.level1Chain, derivbar,
+                       levels.l1, hsp.state.l1x, hsp[].reverse.preProjLevel1Chain,
+                       adj.dgEffbar, adj.dfl1bar, adj.dfl1barL2)
 
-  hypPairStageHVPVJPL2(hsp[], l1, hsp[].work.level2Chain, work.dfl1barL2,
-                       l2, hsp.state.l2x, hsp.work.preProjLevel2Chain,
-                       work.dl1bar, work.dfl2bar, work.dfl2barL3)
+  hypPairStageHVPVJPL2(hsp[], levels.l1, hsp[].reverse.level2Chain, adj.dfl1barL2,
+                       levels.l2, hsp.state.l2x, hsp[].reverse.preProjLevel2Chain,
+                       adj.dl1bar, adj.dfl2bar, adj.dfl2barL3)
 
   # Phase 3: reverse the Level 3 HVP output path back into the tangent state
-  hypOutputStageHVPVJP(hsp[], work.dfl2barL3, l2, work.dl2bar, work.dfcbar)
+  hypOutputStageHVPVJP(hsp[], adj.dfl2barL3, levels.l2, adj.dl2bar, adj.dfcbar)
   threads:
     for mu in 0..<4:
-      work.dflxbar[mu].projHVPVJP_dx(hsp.state.flx[mu], chain[mu], work.dfcbar[mu])
-  hypOutputStageJVPVJP(hsp[], work.dflxbar, l2, work.dgEffbar, work.dl2bar)
+      adj.dflxbar[mu].projHVPVJP_dx(hsp.state.flx[mu], chain[mu], adj.dfcbar[mu])
+  hypOutputStageJVPVJP(hsp[], adj.dflxbar, levels.l2, adj.dgEffbar, adj.dl2bar)
 
   # Phase 4: reverse the Level 2 projection and tangent contributions
-  accumulateProjectionAdjoint(work.dl2xbar, hsp.state.l2x, hsp.work.preProjLevel2Chain, work.dl2bar, work.dfl2bar)
-  hypPairStageJVPVJPL2(hsp[], l1, work.dl2xbar, work.dl1bar, work.dgEffbar)
+  accumulateProjectionAdjoint(adj.dl2xbar, hsp.state.l2x, hsp[].reverse.preProjLevel2Chain, adj.dl2bar, adj.dfl2bar)
+  hypPairStageJVPVJPL2(hsp[], levels.l1, adj.dl2xbar, adj.dl1bar, adj.dgEffbar)
 
   # Phase 5: reverse the Level 1 projection and tangent contributions
-  accumulateProjectionAdjoint(work.dl1xbar, hsp.state.l1x, hsp.work.preProjLevel1Chain, work.dl1bar, work.dfl1bar)
-  hypPairStageJVPVJPL1(hsp[], work.dl1xbar, work.dgEffbar)
+  accumulateProjectionAdjoint(adj.dl1xbar, hsp.state.l1x, hsp[].reverse.preProjLevel1Chain, adj.dl1bar, adj.dfl1bar)
+  hypPairStageJVPVJPL1(hsp[], adj.dl1xbar, adj.dgEffbar)
 
   # Phase 6: return the adjoint with respect to the multiplicative tangent `dg*g`
   threads:
     for mu in 0..<4:
-      gbar[mu] := work.dgEffbar[mu]
+      gbar[mu] := adj.dgEffbar[mu]

From cda6a2a5116d7c9379dd8c2f6b810b3595a9aa91 Mon Sep 17 00:00:00 2001
From: Xiao-Yong Jin <xjin@anl.gov>
Date: Thu, 2 Apr 2026 23:25:41 -0500
Subject: [PATCH 7/7] gauge/hypsmear: rewrite smearGetForce with per-level
 shared code

---
 src/gauge/hypsmear.nim | 678 ++++++++++++++++++++++-------------------
 1 file changed, 364 insertions(+), 314 deletions(-)

diff --git a/src/gauge/hypsmear.nim b/src/gauge/hypsmear.nim
index 4e52efdf..4a3f2782 100644
--- a/src/gauge/hypsmear.nim
+++ b/src/gauge/hypsmear.nim
@@ -133,261 +133,6 @@ template forThird(mu, nu, a, b: untyped; body: untyped) =
       discard b
       body
 
-# L[mu][nu] = P( (1-a1)*g[mu] + 0.5*a1 SS(g[nu],g[mu]) )
-# L2[mu][nu] = P( (1-a2)*g[mu] + 0.25*a2 sum{a,b!=mu,nu} SS(L[a][b],L[mu][b]) )
-# fl[mu] = P( (1-a3)*g[mu] + a3/6 sum{nu!=mu} SS(L2[nu][mu],L2[mu][nu]) )
-#proc smear*(coef: HypCoefs, gf: auto, fl: auto, ht: HypTemps,
-#            info: var PerfInfo) =
-proc smearGetForce*[G](coef: HypCoefs, gf: G, fl: G,
-            info: var PerfInfo):auto =
-  ## Note that the resulting proc, smearedForce, holds a reference to the input gauge gf.
-  ## The correctness of the algorithm depends on gf remaining the same.
-  ## On the contrary, any changes to the smeared gauge fl would have no effects to the force calculation.
-  tic()
-  type lcm = type(gf[0])
-  let lo = gf[0].l
-  proc newlcm: lcm = result.new(gf[0].l)
-  var
-    l1x = newFieldArray2(lo,lcm,[4,4],mu!=nu)
-    l2x = newOneOf(l1x)
-    flx = newFieldArray(lo,lcm,4)
-    tm1: lcm
-    sm1: array[4,Shifter[lcm,type(gf[0][0])]]
-    s1: array[4,array[4,Shifter[lcm,type(gf[0][0])]]]
-    #nflop = 61632.0
-    #dtime = 0.0
-  when keepProj:
-    var
-      l1 = newOneOf(l1x)
-      l2 = newOneOf(l1x)
-  else:
-    var
-      lp1 = newlcm()
-      lp2 = newlcm()
-
-  tm1 = newlcm()
-  for mu in 0..<4:
-    sm1[mu] = newShifter(gf[mu], mu, -1)
-    for nu in 0..<4:
-      if nu!=mu:
-        s1[mu][nu] = newShifter(gf[mu], nu, 1)
-  threads:
-    for mu in 0..<4:
-      for nu in 0..<4:
-        if nu!=mu:
-          discard s1[mu][nu] ^*! gf[mu]
-
-  let
-    alp1 = coef.alpha1 / 2.0
-    alp2 = coef.alpha2 / 4.0
-    alp3 = coef.alpha3 / 6.0
-    ma1 = 1 - coef.alpha1
-    ma2 = 1 - coef.alpha2
-    ma3 = 1 - coef.alpha3
-
-  toc("prep")
-  threads:
-    for mu in 0..<4:
-      for nu in 0..<4:
-        if nu!=mu:
-          l1x[mu,nu] := ma1 * gf[mu]
-          symStaple(l1x[mu,nu], alp1, gf[nu], gf[mu],
-                    s1[nu][mu], s1[mu][nu], tm1, sm1[nu])
-          when keepProj:
-            l1[mu,nu].proj l1x[mu,nu]
-    toc("1")
-
-    for mu in 0..<4:
-      for nu in 0..<4:
-        if nu!=mu:
-          l2x[mu,nu] := ma2 * gf[mu]
-          for a in 0..<4:
-            if a!=mu and a!=nu:
-              let b = 1+2+3-mu-nu-a
-              when keepProj:
-                template lp1:untyped = l1[a,b]
-                template lp2:untyped = l1[mu,b]
-              else:
-                lp1.proj l1x[a,b]
-                lp2.proj l1x[mu,b]
-              threadBarrier()
-              discard s1[nu][mu] ^*! lp1
-              discard s1[mu][a] ^*! lp2
-              threadBarrier()
-              symStaple(l2x[mu,nu], alp2, lp1, lp2,
-                        s1[nu][mu], s1[mu][a], tm1, sm1[a])
-          when keepProj:
-            l2[mu,nu].proj l2x[mu,nu]
-    toc("2")
-
-    when keepProj:
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            threadBarrier()
-            discard s1[mu][nu] ^*! l2[mu,nu]
-
-    for mu in 0..<4:
-      flx[mu] := ma3 * gf[mu]
-      for nu in 0..<4:
-        if nu!=mu:
-          when keepProj:
-            template lp1:untyped = l2[nu,mu]
-            template lp2:untyped = l2[mu,nu]
-          else:
-            lp1.proj l2x[nu,mu]
-            lp2.proj l2x[mu,nu]
-            threadBarrier()
-            discard s1[nu][mu] ^*! lp1
-            discard s1[mu][nu] ^*! lp2
-            threadBarrier()
-          symStaple(flx[mu], alp3, lp1, lp2,
-                    s1[nu][mu], s1[mu][nu], tm1, sm1[nu])
-      fl[mu].proj flx[mu]
-  toc("threads end")
-
-  proc smearedForce(f,chain:G) =
-    tic("smearedF")
-    # fₓₚₜ ← chainₘₖₕ d/dUₓₚₜ^*[Vₘₖₕ(U)^*] + chainₘₕₖ^* d/dUₓₚₜ^*[Vₘₕₖ(U)]
-    var
-      fl1 = newFieldArray2(lo,lcm,[4,4],mu!=nu)
-      fl2 = newOneOf(fl1)
-      fc = newFieldArray(lo,lcm,4)
-      fs: array[4,Shifter[lcm,type(gf[0][0])]]
-      tm2: lcm
-    tm2 = newlcm()
-    for mu in 0..<4:
-      fs[mu] = newShifter(fc[mu], mu, 1)
-    toc("prep")
-
-    threads:
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            fl1[mu,nu] := 0
-            fl2[mu,nu] := 0
-
-      # proj flx → fl, fc ← chain
-      for mu in 0..<4:
-        fc[mu].projDeriv(flx[mu], chain[mu])
-      # link (gf, l2) → flx, (f, fl2) ← fc
-      for mu in 0..<4:
-        f[mu] := ma3 * fc[mu]
-        fc[mu] *= alp3
-      when keepProj:
-        for mu in 0..<4:
-          for nu in 0..<4:
-            if nu!=mu:
-              threadBarrier()
-              discard s1[mu][nu] ^*! l2[mu,nu]
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            when keepProj:
-              template lp1:untyped = l2[nu,mu]
-              template lp2:untyped = l2[mu,nu]
-            else:
-              lp1.proj l2x[nu,mu]
-              lp2.proj l2x[mu,nu]
-              threadBarrier()
-              discard s1[nu][mu] ^*! lp1
-              discard s1[mu][nu] ^*! lp2
-            discard fs[nu] ^*! fc[mu]
-            threadBarrier()
-            symStapleDeriv(fl2[nu,mu], fl2[mu,nu],
-                           lp1, lp2, s1[nu][mu], s1[mu][nu],
-                           fc[mu], fs[nu], tm1, tm2, sm1[nu], sm1[mu])
-      toc("1")
-
-      # proj l2x → l2, fl2 ← fl2
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            when keepProj:
-              fl2[mu,nu].projDeriv(l2[mu,nu], l2x[mu,nu], fl2[mu,nu])
-            else:
-              fl2[mu,nu].projDeriv(l2x[mu,nu], fl2[mu,nu])
-      # link (gf, l1) → l2x, (f, fl1) ← fl2
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            f[mu] += ma2 * fl2[mu,nu]
-            fl2[mu,nu] *= alp2
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            for a in 0..<4:
-              if a!=mu and a!=nu:
-                let b = 1+2+3-mu-nu-a
-                when keepProj:
-                  template lp1:untyped = l1[a,b]
-                  template lp2:untyped = l1[mu,b]
-                else:
-                  lp1.proj l1x[a,b]
-                  lp2.proj l1x[mu,b]
-                threadBarrier()
-                discard s1[nu][mu] ^*! lp1
-                discard s1[mu][a] ^*! lp2
-                discard fs[a] ^*! fl2[mu,nu]
-                threadBarrier()
-                symStapleDeriv(fl1[a,b], fl1[mu,b],
-                               lp1, lp2, s1[nu][mu], s1[mu][a],
-                               fl2[mu,nu], fs[a], tm1, tm2, sm1[a], sm1[mu])
-      toc("2")
-
-      # proj l1x → l1, fl1 ← fl1
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            when keepProj:
-              fl1[mu,nu].projDeriv(l1[mu,nu], l1x[mu,nu], fl1[mu,nu])
-            else:
-              fl1[mu,nu].projDeriv(l1x[mu,nu], fl1[mu,nu])
-            discard s1[mu][nu] ^*! gf[mu]
-      # link gf → l1, f ← fl1
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            f[mu] += ma1 * fl1[mu,nu]
-            fl1[mu,nu] *= alp1
-      for mu in 0..<4:
-        for nu in 0..<4:
-          if nu!=mu:
-            discard fs[nu] ^* fl1[mu,nu]
-            symStapleDeriv(f[nu], f[mu],
-                           gf[nu], gf[mu], s1[nu][mu], s1[mu][nu],
-                           fl1[mu,nu], fs[nu], tm1, tm2, sm1[nu], sm1[mu])
-    toc("end")
-
-  toc("end")
-  smearedForce
-
-proc smearPriv[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) {.codegenDecl:
-    "__attribute__((noinline)) $# $#$#".} =
-  # Avoid inlining or other compiler optimizations
-  # in order to guarantee the change of the stack pointer,
-  # such that Nim's GC is able to collect the memory.
-  {.emit: "asm (\"\");".}
-  var f = coef.smearGetForce(gf, fl, info)
-  f = nil
-proc smear*[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) =
-  ## Try our best to release memory here.
-  ## Sometimes it still requires a GC after this function returns.
-  coef.smearPriv(gf, fl, info)
-  qexGC()
-
-#proc smear*(c: HypCoefs, gf: auto, fl: auto, info: var PerfInfo) =
-#  var t = newHypTemps(gf)
-#  smear(c, gf, fl, t, info)
-
-proc smear*(c: HypCoefs, g: auto, fl: auto) =
-  var info: PerfInfo
-  c.smear(g, fl, info)
-
-#proc deriv*(coef: HypCoefs, gf: auto, fl: auto, info: var PerfInfo) =
-#  ## Compatibility wrapper around the shared forward HYP builder.
-#  coef.smear(gf, fl, info)
-
 # Preallocated HYP smearing environment, following stoutsmear style
 type
   HypForwardState[V:static[int],F,T] = object
@@ -708,6 +453,42 @@ template projectAndScalePairChain(chain, projected, xfield, preProjChain,
         derivSink[mu] += ma * chain[mu,nu]
       chain[mu,nu] *= alp
 
+template projectAndScalePairChainInPlace(chain, projected, xfield,
+                                         alp, derivSink, ma: untyped;
+                                         accumulateDirect: static bool) =
+  threads:
+    forPairs(mu, nu):
+      chain[mu,nu].projVJP(projected[mu,nu], xfield[mu,nu], chain[mu,nu])
+
+  threads:
+    forPairs(mu, nu):
+      when accumulateDirect:
+        derivSink[mu] += ma * chain[mu,nu]
+      chain[mu,nu] *= alp
+
+template projectAndScaleProjectedPairChainInPlace(chain, xfield,
+                                                  alp, derivSink, ma: untyped;
+                                                  accumulateDirect: static bool) =
+  threads:
+    forPairs(mu, nu):
+      chain[mu,nu].projVJP(xfield[mu,nu], chain[mu,nu])
+
+  threads:
+    forPairs(mu, nu):
+      when accumulateDirect:
+        derivSink[mu] += ma * chain[mu,nu]
+      chain[mu,nu] *= alp
+
+template projectAndScaleOutputChain(outputChain, flx, chain,
+                                    alp, derivSink, ma: untyped;
+                                    accumulateDirect: static bool) =
+  threads:
+    for mu in 0..<4:
+      outputChain[mu].projVJP(flx[mu], chain[mu])
+      when accumulateDirect:
+        derivSink[mu] := ma * outputChain[mu]
+      outputChain[mu] *= alp
+
 template clearReverseChains(outputChain, level1Chain, level2Chain: auto) =
   threads:
     for mu in 0..<4:
@@ -794,20 +575,48 @@ template forLevel3Pairs(hs, l2, pl1, pl2: untyped; body: untyped) =
       let pl2 = l2[mu,nu]
       body
 
+template hypOutputStageStapleVJPCore(l2, pairShift, sm1, tm1,
+                                     outputChain, chainShift, tm2, level2Chain: untyped) =
+  threads:
+    forPairs(mu, nu):
+      let pl1 = l2[nu,mu]
+      let pl2 = l2[mu,nu]
+      threadBarrier()
+      discard chainShift[nu] ^*! outputChain[mu]
+      threadBarrier()
+      symStapleVJP(level2Chain[nu,mu], level2Chain[mu,nu],
+                   pl1, pl2,
+                   pairShift[nu][mu], pairShift[mu][nu],
+                   outputChain[mu], chainShift[nu],
+                   tm1, tm2, sm1[nu], sm1[mu])
+      threadBarrier()
+
+template hypOutputStageProjectedStapleVJPCore(l2x, lp1, lp2, pairShift, sm1, tm1,
+                                              outputChain, chainShift, tm2, level2Chain: untyped) =
+  threads:
+    forPairs(mu, nu):
+      lp1.proj l2x[nu,mu]
+      lp2.proj l2x[mu,nu]
+      threadBarrier()
+      discard pairShift[nu][mu] ^*! lp1
+      discard pairShift[mu][nu] ^*! lp2
+      discard chainShift[nu] ^*! outputChain[mu]
+      threadBarrier()
+      symStapleVJP(level2Chain[nu,mu], level2Chain[mu,nu],
+                   lp1, lp2,
+                   pairShift[nu][mu], pairShift[mu][nu],
+                   outputChain[mu], chainShift[nu],
+                   tm1, tm2, sm1[nu], sm1[mu])
+      threadBarrier()
+
 proc hypOutputStageStapleVJP*(hs: var HypSmear, l2, outputChain: auto;
                               level2Chain: auto) =
   hs.ensureKernelScratch()
   let hsp = hs.addr
-  forLevel3Pairs(hsp[], l2, pl1, pl2):
-    threadBarrier()
-    discard hsp[].kernel.chainShift[nu] ^*! outputChain[mu]
-    threadBarrier()
-    symStapleVJP(level2Chain[nu,mu], level2Chain[mu,nu],
-                 pl1, pl2,
-                 hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
-                 outputChain[mu], hsp[].kernel.chainShift[nu],
-                 hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
-    threadBarrier()
+  primeLevel3PairShifts(hsp[], l2)
+  hypOutputStageStapleVJPCore(l2, hsp[].state.stagePairShift, hsp[].state.sm1, hsp[].state.tm1,
+                              outputChain, hsp[].kernel.chainShift, hsp[].kernel.tm2,
+                              level2Chain)
 
 proc hypOutputStageChainVJP*(hs: var HypSmear, l2, seedBar: auto;
                              outputChainBar: auto) =
@@ -851,21 +660,69 @@ template forPairStageForwardTerms(hs, stage, pairSrc,
       body
       threadBarrier()
 
+template hypPairStageL1ForwardCore(gf, pairShift, sm1, tm1, ma, alp,
+                                   outX, outProj: untyped;
+                                   doProj, barrierAfterStaple: static bool) =
+  threads:
+    forPairs(mu, nu):
+      outX[mu,nu] := ma * gf[mu]
+      symStaple(outX[mu,nu], alp, gf[nu], gf[mu],
+                pairShift[nu][mu], pairShift[mu][nu], tm1, sm1[nu])
+      when barrierAfterStaple:
+        threadBarrier()
+      when doProj:
+        outProj[mu,nu].proj outX[mu,nu]
+
+template hypPairStageL2ForwardCore(gf, pairSrc, pairShift, sm1, tm1, ma, alp,
+                                   outX, outProj: untyped;
+                                   doProj: static bool) =
+  threads:
+    forPairs(mu, nu):
+      outX[mu,nu] := ma * gf[mu]
+      forThird(mu, nu, a, b):
+        let pl1 = pairSrc[a,b]
+        let pl2 = pairSrc[mu,b]
+        threadBarrier()
+        discard pairShift[nu][mu] ^*! pl1
+        discard pairShift[mu][a] ^*! pl2
+        threadBarrier()
+        symStaple(outX[mu,nu], alp, pl1, pl2,
+                  pairShift[nu][mu], pairShift[mu][a], tm1, sm1[a])
+        threadBarrier()
+      when doProj:
+        outProj[mu,nu].proj outX[mu,nu]
+
+template hypPairStageL2ForwardProjectedCore(gf, pairSrcX, lp1, lp2, pairShift, sm1, tm1,
+                                            ma, alp, outX, outProj: untyped;
+                                            doProj: static bool) =
+  threads:
+    forPairs(mu, nu):
+      outX[mu,nu] := ma * gf[mu]
+      forThird(mu, nu, a, b):
+        lp1.proj pairSrcX[a,b]
+        lp2.proj pairSrcX[mu,b]
+        threadBarrier()
+        discard pairShift[nu][mu] ^*! lp1
+        discard pairShift[mu][a] ^*! lp2
+        threadBarrier()
+        symStaple(outX[mu,nu], alp, lp1, lp2,
+                  pairShift[nu][mu], pairShift[mu][a], tm1, sm1[a])
+      when doProj:
+        outProj[mu,nu].proj outX[mu,nu]
+
 template hypPairStageForward(stage, hs, pairSrc, outX, outProj: untyped) =
   block:
     let hsp = hs.addr
     let sc = pairStageScales(hsp[], stage)
     primePairStageForwardShifts(hsp[], stage)
-
-    threads:
-      forPairs(mu, nu):
-        outX[mu,nu] := sc.ma * hsp[].state.gf[mu]
-        forPairStageForwardTerms(hsp[], stage, pairSrc, mu, nu, pl1, pl2, sh1, sh2, smDir):
-          symStaple(outX[mu,nu], sc.alp, pl1, pl2,
-                    sh1, sh2, hsp[].state.tm1, hsp[].state.sm1[smDir])
-        when stage == psL1:
-          threadBarrier()
-        outProj[mu,nu].proj outX[mu,nu]
+    when stage == psL1:
+      hypPairStageL1ForwardCore(hsp[].state.gf, hsp[].state.gaugePairShift,
+                                hsp[].state.sm1, hsp[].state.tm1, sc.ma, sc.alp,
+                                outX, outProj, true, true)
+    else:
+      hypPairStageL2ForwardCore(hsp[].state.gf, pairSrc, hsp[].state.stagePairShift,
+                                hsp[].state.sm1, hsp[].state.tm1, sc.ma, sc.alp,
+                                outX, outProj, true)
 
 ## Pair-stage operator family split into explicit Level-1/Level-2 entry points.
 proc hypPairStageL1*(hs: var HypSmear; outX, outProj: auto) =
@@ -875,6 +732,44 @@ proc hypPairStageL2*(hs: var HypSmear, pairSrc: auto;
                      outX, outProj: auto) =
   hypPairStageForward(psL2, hs, pairSrc, outX, outProj)
 
+template hypOutputForwardCore(gf, l2, pairShift, sm1, tm1, ma, alp,
+                              flx, fl: untyped;
+                              primeShifts, doProj: static bool) =
+  when primeShifts:
+    threads:
+      forPairs(mu, nu):
+        discard pairShift[mu][nu] ^*! l2[mu,nu]
+
+  threads:
+    for mu in 0..<4:
+      flx[mu] := ma * gf[mu]
+      forNu(mu, nu):
+        let pl1 = l2[nu,mu]
+        let pl2 = l2[mu,nu]
+        symStaple(flx[mu], alp, pl1, pl2,
+                  pairShift[nu][mu], pairShift[mu][nu], tm1, sm1[nu])
+        threadBarrier()
+      when doProj:
+        fl[mu].proj flx[mu]
+
+template hypOutputForwardProjectedCore(gf, l2x, lp1, lp2, pairShift, sm1, tm1,
+                                       ma, alp, flx, fl: untyped;
+                                       doProj: static bool) =
+  threads:
+    for mu in 0..<4:
+      flx[mu] := ma * gf[mu]
+      forNu(mu, nu):
+        lp1.proj l2x[nu,mu]
+        lp2.proj l2x[mu,nu]
+        threadBarrier()
+        discard pairShift[nu][mu] ^*! lp1
+        discard pairShift[mu][nu] ^*! lp2
+        threadBarrier()
+        symStaple(flx[mu], alp, lp1, lp2,
+                  pairShift[nu][mu], pairShift[mu][nu], tm1, sm1[nu])
+      when doProj:
+        fl[mu].proj flx[mu]
+
 template hypPairStageJVPPtr(stage, hsp, pairSrc, tangentSrc, shiftedTangents,
                          preProjBase, projBase, dgEff, preProjOut, tangentOut: untyped) =
   block:
@@ -938,34 +833,74 @@ template hypPairStageJVPL2*(hs, pairSrc, tangentSrc, shiftedTangents,
   hypPairStageJVPL2Ptr(hs.addr, pairSrc, tangentSrc, shiftedTangents,
                        preProjBase, projBase, dgEff, preProjOut, tangentOut)
 
+template hypPairStageL2StapleVJPCore(pairSrc, pairShift, sm1, tm1,
+                                     chainIn, chainShift, tm2, dst: untyped) =
+  threads:
+    forPairs(mu, nu):
+      forThird(mu, nu, a, b):
+        let pl1 = pairSrc[a,b]
+        let pl2 = pairSrc[mu,b]
+        threadBarrier()
+        discard pairShift[nu][mu] ^*! pl1
+        discard pairShift[mu][a] ^*! pl2
+        discard chainShift[a] ^*! chainIn[mu,nu]
+        threadBarrier()
+        symStapleVJP(dst[a,b], dst[mu,b],
+                     pl1, pl2,
+                     pairShift[nu][mu], pairShift[mu][a],
+                     chainIn[mu,nu], chainShift[a],
+                     tm1, tm2, sm1[a], sm1[mu])
+        threadBarrier()
+
+template hypPairStageL2ProjectedStapleVJPCore(pairSrcX, lp1, lp2, pairShift, sm1, tm1,
+                                              chainIn, chainShift, tm2, dst: untyped) =
+  threads:
+    forPairs(mu, nu):
+      forThird(mu, nu, a, b):
+        lp1.proj pairSrcX[a,b]
+        lp2.proj pairSrcX[mu,b]
+        threadBarrier()
+        discard pairShift[nu][mu] ^*! lp1
+        discard pairShift[mu][a] ^*! lp2
+        discard chainShift[a] ^*! chainIn[mu,nu]
+        threadBarrier()
+        symStapleVJP(dst[a,b], dst[mu,b],
+                     lp1, lp2,
+                     pairShift[nu][mu], pairShift[mu][a],
+                     chainIn[mu,nu], chainShift[a],
+                     tm1, tm2, sm1[a], sm1[mu])
+        threadBarrier()
+
+template hypPairStageL1StapleVJPCore(gf, pairShift, sm1, tm1,
+                                     chainIn, chainShift, tm2, dst: untyped;
+                                     primeGaugeShifts: static bool) =
+  when primeGaugeShifts:
+    threads:
+      forPairs(mu, nu):
+        discard pairShift[mu][nu] ^*! gf[mu]
+
+  threads:
+    forPairs(mu, nu):
+      discard chainShift[nu] ^* chainIn[mu,nu]
+      symStapleVJP(dst[nu], dst[mu],
+                   gf[nu], gf[mu],
+                   pairShift[nu][mu], pairShift[mu][nu],
+                   chainIn[mu,nu], chainShift[nu],
+                   tm1, tm2, sm1[nu], sm1[mu])
+      threadBarrier()
+
 template hypPairStageStapleVJP(stage, hs, pairSrc, chainIn, dst: untyped) =
   block:
     let hsp = hs.addr
-    threads:
-      forPairs(mu, nu):
-        when stage == psL1:
-          discard hsp[].kernel.chainShift[nu] ^* chainIn[mu,nu]
-          symStapleVJP(dst[nu], dst[mu],
-                       hsp[].state.gf[nu], hsp[].state.gf[mu],
-                       hsp[].state.gaugePairShift[nu][mu], hsp[].state.gaugePairShift[mu][nu],
-                       chainIn[mu,nu], hsp[].kernel.chainShift[nu],
-                       hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[nu], hsp[].state.sm1[mu])
-          threadBarrier()
-        else:
-          forThird(mu, nu, a, b):
-            let pl1 = pairSrc[a,b]
-            let pl2 = pairSrc[mu,b]
-            threadBarrier()
-            discard hsp[].state.stagePairShift[nu][mu] ^*! pl1
-            discard hsp[].state.stagePairShift[mu][a] ^*! pl2
-            discard hsp[].kernel.chainShift[a] ^*! chainIn[mu,nu]
-            threadBarrier()
-            symStapleVJP(dst[a,b], dst[mu,b],
-                         pl1, pl2,
-                         hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][a],
-                         chainIn[mu,nu], hsp[].kernel.chainShift[a],
-                         hsp[].state.tm1, hsp[].kernel.tm2, hsp[].state.sm1[a], hsp[].state.sm1[mu])
-            threadBarrier()
+    when stage == psL1:
+      hypPairStageL1StapleVJPCore(hsp[].state.gf, hsp[].state.gaugePairShift,
+                                  hsp[].state.sm1, hsp[].state.tm1,
+                                  chainIn, hsp[].kernel.chainShift, hsp[].kernel.tm2,
+                                  dst, false)
+    else:
+      hypPairStageL2StapleVJPCore(pairSrc, hsp[].state.stagePairShift, hsp[].state.sm1,
+                                  hsp[].state.tm1, chainIn, hsp[].kernel.chainShift,
+                                  hsp[].kernel.tm2, dst)
 
 proc hypPairStageStapleVJPL1*(hs: var HypSmear, chainIn: auto; dst: auto) =
   hs.ensureKernelScratch()
@@ -1221,20 +1156,9 @@ proc hypPairStageJVPVJPL2*(hs: var HypSmear, pairSrc, tangentXBar: auto;
 proc hypOutputStage*(hs: var HypSmear, l2: auto; flx, fl: auto) =
   let hsp = hs.addr
   let sc = outputStageScales(hsp[])
-  threads:
-    forPairs(mu, nu):
-      discard hsp[].state.stagePairShift[mu][nu] ^*! l2[mu,nu]
-  threads:
-    for mu in 0..<4:
-      flx[mu] := sc.ma * hsp[].state.gf[mu]
-      forNu(mu, nu):
-        let pl1 = l2[nu,mu]
-        let pl2 = l2[mu,nu]
-        symStaple(flx[mu], sc.alp, pl1, pl2,
-                  hsp[].state.stagePairShift[nu][mu], hsp[].state.stagePairShift[mu][nu],
-                  hsp[].state.tm1, hsp[].state.sm1[nu])
-        threadBarrier()
-      fl[mu].proj flx[mu]
+  hypOutputForwardCore(hsp[].state.gf, l2, hsp[].state.stagePairShift,
+                       hsp[].state.sm1, hsp[].state.tm1, sc.ma, sc.alp,
+                       flx, fl, true, true)
 
 template hypOutputStageJVPPtr(hsp, l2, dl2, dsl2, dgEff, dflx: untyped) =
   let dsl2p = dsl2.addr
@@ -1649,3 +1573,129 @@ proc smearHVPVJP*[G](hs: var HypSmear, gbar: G, derivbar: G, chain: G) =
   threads:
     for mu in 0..<4:
       gbar[mu] := adj.dgEffbar[mu]
+
+# Compatibility wrappers around the reusable HypSmear engine.
+proc smearGetForce*[G](coef: HypCoefs, gf: G, fl: G,
+            info: var PerfInfo):auto =
+  ## The resulting proc still depends on the original `gf`.
+  ## The correctness of the algorithm depends on `gf` remaining the same.
+  ## Changes to the smeared gauge `fl` do not affect the force calculation.
+  type lcm = type(gf[0])
+  let lo = gf[0].l
+  proc newlcm: lcm = result.new(gf[0].l)
+  var
+    l1x = newFieldArray2(lo,lcm,[4,4],mu!=nu)
+    l2x = newOneOf(l1x)
+    flx = newFieldArray(lo,lcm,4)
+    tm1: lcm
+    sm1: array[4,Shifter[lcm,type(gf[0][0])]]
+    s1: array[4,array[4,Shifter[lcm,type(gf[0][0])]]]
+  when keepProj:
+    var
+      l1 = newOneOf(l1x)
+      l2 = newOneOf(l1x)
+  else:
+    var
+      lp1 = newlcm()
+      lp2 = newlcm()
+
+  tm1 = newlcm()
+  for mu in 0..<4:
+    sm1[mu] = newShifter(gf[mu], mu, -1)
+    for nu in 0..<4:
+      if nu!=mu:
+        s1[mu][nu] = newShifter(gf[mu], nu, 1)
+
+  let
+    alp1 = coef.alpha1 / 2.0
+    alp2 = coef.alpha2 / 4.0
+    alp3 = coef.alpha3 / 6.0
+    ma1 = 1 - coef.alpha1
+    ma2 = 1 - coef.alpha2
+    ma3 = 1 - coef.alpha3
+
+  threads:
+    forPairs(mu, nu):
+      discard s1[mu][nu] ^*! gf[mu]
+
+  when keepProj:
+    hypPairStageL1ForwardCore(gf, s1, sm1, tm1, ma1, alp1, l1x, l1, true, true)
+  else:
+    hypPairStageL1ForwardCore(gf, s1, sm1, tm1, ma1, alp1, l1x, l1x, false, true)
+
+  when keepProj:
+    hypPairStageL2ForwardCore(gf, l1, s1, sm1, tm1, ma2, alp2, l2x, l2, true)
+  else:
+    hypPairStageL2ForwardProjectedCore(gf, l1x, lp1, lp2, s1, sm1, tm1,
+                                       ma2, alp2, l2x, l2x, false)
+
+  when keepProj:
+    hypOutputForwardCore(gf, l2, s1, sm1, tm1, ma3, alp3, flx, fl, true, true)
+  else:
+    hypOutputForwardProjectedCore(gf, l2x, lp1, lp2, s1, sm1, tm1,
+                                  ma3, alp3, flx, fl, true)
+
+  proc smearedForce(f,chain:G) =
+    var
+      fl1 = newFieldArray2(lo,lcm,[4,4],mu!=nu)
+      fl2 = newOneOf(fl1)
+      fc = newFieldArray(lo,lcm,4)
+      fs: array[4,Shifter[lcm,type(gf[0][0])]]
+      tm2: lcm
+    tm2 = newlcm()
+    for mu in 0..<4:
+      fs[mu] = newShifter(fc[mu], mu, 1)
+
+    threads:
+      forPairs(mu, nu):
+        fl1[mu,nu] := 0
+        fl2[mu,nu] := 0
+
+    projectAndScaleOutputChain(fc, flx, chain, alp3, f, ma3, true)
+
+    when keepProj:
+      threads:
+        forPairs(mu, nu):
+          threadBarrier()
+          discard s1[mu][nu] ^*! l2[mu,nu]
+
+      hypOutputStageStapleVJPCore(l2, s1, sm1, tm1, fc, fs, tm2, fl2)
+    else:
+      hypOutputStageProjectedStapleVJPCore(l2x, lp1, lp2, s1, sm1, tm1,
+                                           fc, fs, tm2, fl2)
+
+    when keepProj:
+      projectAndScalePairChainInPlace(fl2, l2, l2x, alp2, f, ma2, true)
+      hypPairStageL2StapleVJPCore(l1, s1, sm1, tm1, fl2, fs, tm2, fl1)
+    else:
+      projectAndScaleProjectedPairChainInPlace(fl2, l2x, alp2, f, ma2, true)
+      hypPairStageL2ProjectedStapleVJPCore(l1x, lp1, lp2, s1, sm1, tm1,
+                                           fl2, fs, tm2, fl1)
+
+    when keepProj:
+      projectAndScalePairChainInPlace(fl1, l1, l1x, alp1, f, ma1, true)
+      hypPairStageL1StapleVJPCore(gf, s1, sm1, tm1, fl1, fs, tm2, f, true)
+    else:
+      projectAndScaleProjectedPairChainInPlace(fl1, l1x, alp1, f, ma1, true)
+      hypPairStageL1StapleVJPCore(gf, s1, sm1, tm1, fl1, fs, tm2, f, true)
+
+  smearedForce
+
+proc smearPriv[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) {.codegenDecl:
+    "__attribute__((noinline)) $# $#$#".} =
+  # Avoid inlining or other compiler optimizations
+  # in order to guarantee the change of the stack pointer,
+  # such that Nim's GC is able to collect the memory.
+  {.emit: "asm (\"\");".}
+  var hs = newHypSmear(gf[0].l, coef)
+  hs.smear(gf, fl)
+
+proc smear*[G](coef: HypCoefs, gf: G, fl: G, info: var PerfInfo) =
+  ## Try our best to release memory here.
+  ## Sometimes it still requires a GC after this function returns.
+  coef.smearPriv(gf, fl, info)
+  qexGC()
+
+proc smear*(c: HypCoefs, g: auto, fl: auto) =
+  var info: PerfInfo
+  c.smear(g, fl, info)