diff --git a/reviews/lm006_product_transverse_20261006/NOTE.md b/reviews/lm006_product_transverse_20261006/NOTE.md
new file mode 100644
index 000000000..1532dad32
--- /dev/null
+++ b/reviews/lm006_product_transverse_20261006/NOTE.md
@@ -0,0 +1,225 @@
+# LM006: exact transverse conditioning for an axial product covariance
+
+Dylan Roy — delegated AI mathematical work. Actual author OpenAI / GPT-6
+Astra Pro, `lm006-product-residual-r21a-20261006`. Scientific effect NONE.
+Additive analytic companion; not a Lean proof, numerical certificate or status
+change. Gaussian orthogonal regression and separable kernels are prior methods;
+no general novelty or complete literature search is claimed.
+
+## 1. Scope and source identities
+
+Assume a centered real jointly Gaussian field has the ACTUAL covariance
+
+    C((x,y),(s,t)) = rho(x-s) kappa(y-t), rho(0)=kappa(0)=1,      (1)
+
+with real even factors and enough mean-square derivatives for every displayed
+observation. Write F(x)=f(x,0), H(x)=f_y(x,0), Q(x)=f_yy(x,0), and
+
+    m2=-kappa''(0), m4=kappa''''(0), g=m4-m2^2>0.
+
+The primary result is finite-radius, and only requires the F derivatives
+through order2, H through order1 and Q through transverse order2 that occur
+below. Existence/continuity of higher contact jets is stated separately where
+used. No finite fourth moment is silently relabeled a tenth spectral moment.
+
+P is `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md`,
+read at `91821f9262b30ce7684b8ec5f1b4742893dac3d7`, blob
+`dfed3b8d318a3ab1950957f393307733a4bef3f2`, sections1-2 ONLY as model/pin
+source. Its global selection and lifetime theorem candidates are not premises.
+E is #301 NOTE at `e31b6ad8356e0760c8a7fb6e816ff640c45176c9`, blob
+`551aa563562bc88a19e33d146259c03aa2d318f6`: adjusted endpoint convention.
+N is #315 NOTE at `5e027afcae8c7bd42a6df8ae2025f82105b3e586`, blob
+`5790aaa0332bd8e79b276be1577e4c5f3502eed6`: exact typed weight/normalization.
+B is #341 NOTE at `771913a7dffdc1283e491166d0faa9ec53e1f06a`, blob
+`88dae06c5eefd102239f976513eb5e97c4ac7580`: prior general sign-band theorem
+and eleven-observation density interface. That proof and review are unchanged;
+this is a PRODUCT specialization, not a replacement for its general spectrum.
+
+All formulas concern coordinate-axis separation. A rotated separable torus
+covariance need not remain separable in the rotated coordinates. This note
+does not assert arbitrary-orientation identities or independence after tilting.
+
+## 2. Independent transverse residual process
+
+Define R(x)=Q(x)+m2 F(x). Differentiating (1) gives for every x,s
+
+    Cov(F(x),F(s))=rho(x-s),
+    Cov(H(x),F(s))=Cov(Q(x),H(s))=0,
+    Cov(Q(x),F(s))=-m2 rho(x-s),
+    Cov(H(x),H(s))=m2 rho(x-s),
+    Cov(Q(x),Q(s))=m4 rho(x-s).
+
+The zero mixed terms use kappa'(0)=kappa'''(0)=0, not independence guessed
+from a marginal covariance. Hence
+
+    Cov(R(x),F(s))=Cov(R(x),H(s))=0,
+    Cov(R(x),R(s))=g rho(x-s).                              (2)
+
+Every finite family of R evaluations is independent of every finite family
+of F,H evaluations. This is the jointly Gaussian zero-cross-covariance rule.
+Taking mean-square limits preserves orthogonality and Gaussianity, so the
+same independence holds with any existing F,H derivative observations. The
+claims below need only finite such families; no path-space conditioning theorem
+is required. In particular, axial and mixed Hessian observations provide no
+additional information about R once their F,H families have been separated.
+
+## 3. Exact conditional law after all eleven observations
+
+Let M=-r/2, S=r/2 and c=rho(r), with -1<c<1. Put
+
+ B=(F(M),F'(M),F''(M),F(S),F'(S),F''(S),
+                      H(M),H'(M),H(S),H'(S)).
+
+Assume Cov(B) is positive definite. This makes the canonical Gaussian law
+well-defined at every finite prescribed B value. Under (2), B is independent
+of (R(M),R(S)), whose covariance is g[[1,c],[c,1]]. Let
+
+    J=R(S)-R(M), W=[R(S)+R(M)]/2.
+
+Their covariance is zero, so they are independent Gaussian variables with
+
+    Var(J)=2g(1-c), Var(W)=g(1+c)/2.
+
+The eleven observations in B's sign-band setting are precisely B together
+with G=Q(S)-Q(M). For fixed B,
+
+    J=G+m2[F(S)-F(M)],
+    Q(S)=W+G/2-m2[F(S)+F(M)]/2.
+
+W is independent of (B,J), hence of (B,G). Consequently
+
+ Q(S) | (B,G) ~ N(G/2-m2[F(S)+F(M)]/2, g[1+rho(r)]/2).     (3)
+
+This proves the mean AND variance, with no eleven-by-eleven inverse or
+coalescing-coordinate estimate. B's positive Gram and g(1-c)>0 also give a
+positive eleven-observation Gram; the target has positive residual since c>-1.
+
+On E's actual six pins F(M)=b_M,F(S)=b_S,F'=H=0, the adjusted coordinates
+are a_±=F''(±r/2)/r, b_±=H'(±r/2)/r, c_±=Q(±r/2). Thus conditioning first
+on the pins and then on (a_-,a_+,b_-,b_+,G) is exactly the conditioning in (3):
+the missing four observations are recovered by multiplying by r, while the
+original pins are retained. Neither Q(S)/r nor an extra Jacobian is introduced.
+The conditional density cap is exactly
+
+    D_r = [pi g(1+rho(r))]^(-1/2).                           (4)
+
+If rho(r)>=0, D_r<=1/sqrt(pi g). For a general product covariance this
+last uniform bound REQUIRES that extra sign condition. Positive definiteness
+only gives |rho|<=1, not rho>=0. A negative-correlation control is retained.
+
+Under the six pins ALONE, the transverse pair is a translate of the same
+R pair, independent of the four axial/mixed endpoint coordinates, with
+
+    E G=m2(b_M-b_S), Var(G)=2g[1-rho(r)],
+    E G^2=m2^2(b_M-b_S)^2+2g[1-rho(r)].                    (5)
+
+This independence is under the original Gaussian pin law, not the law tilted
+by the product of Hessian determinants. The tilted density couples coordinates.
+
+## 4. Contact variance, limiting normalizer, and direct G bound
+
+Where the contact derivatives exist, the six original contact pins consist
+of F,F',H,F'',H',F''' at0, with F=b and the remaining prescribed values as
+in E. R(0) is independent of all those rows by (2), so
+
+    Q_L ~ N(-m2 b,g).                                      (6)
+
+This does not identify g with the normalizer. If the enlarged eleven contact
+jets B discusses also exist, they add pure F and H derivatives and Q'(0).
+Cov(R(0),Q'(0))=g rho'(0)=0. Thus its exact scalar residual variance is ALSO g,
+not merely a positive unspecified Schur complement. Their joint Gram still
+requires nondegeneracy if conditioning at arbitrary targets is intended.
+
+For b>=0, the negative-part monotonicity gives
+
+    z0=E[(Q_L)_-^2]>=g/2>0.                                (7)
+
+An optional closed form follows by two integrations by parts of the standard
+normal density phi: with a=m2 b/sqrt(g),
+
+    z0=(g+m2^2 b^2)Phi(a)+m2 b sqrt(g)phi(a).               (8)
+
+Indeed Q_L=sqrt(g)(Z-a), and integrals of Z phi and Z^2 phi on(-infinity,a]
+are -phi(a) and Phi(a)-a phi(a). Formula (8) holds for any real b; (7) is
+only claimed for b>=0. No numeric evaluation of these constants is supplied.
+
+Suppose rho is an even spectral correlation with finite axial second moment
+s2=-rho''(0). Since 1-cos u<=u^2/2, 1-rho(r)<=s2 r^2/2. Under the fixed
+LM006 gap b_M-b_S=r^3/6, (5) yields
+
+    E G^2<=g s2 r^2+m2^2 r^6/36
+           <=Gamma r^2, Gamma=g s2+m2^2/36, 0<r<=1.        (9)
+
+This is a direct same-law bound, not an assumed full-vector coupling rate.
+Using the band integration already derived in B, or directly integrating
+(gap-t)(r b_+^2+(a_+)_-t), Cauchy-Schwarz and Gaussian fourth/sixth moments give
+
+ N_r=E[T_r 1_{c_+>=0}]
+   <=D_r[(r/2)sqrt(3 K6) E G^2
+                     +(1/6)sqrt(15 K4)(E G^2)^(3/2)],
+ K4=E[a_-^2 a_+^2], K6=E[a_-^2 b_+^4].                    (10)
+
+If K4<=C4,K6<=C6,z_r=E T_r>=z_*>0 and rho(r)>=0 on one interval, then
+
+ nu_r{c_+>=0} <= min(1,
+   [sqrt(3 C6)Gamma/2+sqrt(15 C4)Gamma^(3/2)/6]
+                       r^3/[z_* sqrt(pi g)]).             (11)
+
+The new identities supply D_r and Gamma, NOT the remaining uniform moment
+bounds or a finite-r normalizer radius. Those are separate input obligations
+before applying (11). In the smooth fixed model, E's established moment/UI
+argument supplies such inputs on a sufficiently small interval; this note is
+not a new review of that entire argument. The algebra of (10) uses no
+independence under the tilted law and no physical-normalizer substitution.
+
+## 5. Exact model match and scope failures
+
+P's d=2 coordinate-axis covariance factors by its positive image sums as
+
+    rho_L(x)=sum_n exp(-(x+Ln)^2/2)/sum_n exp(-(Ln)^2/2),
+    K_L(x,y)=rho_L(x)rho_L(y).                              (12)
+
+Hence kappa=rho_L, g=m4-m2^2 for its actual one-dimensional spectral moments.
+All spectral moments are finite, g>0 because both zero and nonzero squared
+frequencies have positive mass, and rho_L(r)>0 for every real r. Its full
+lattice spectrum gives the positive Gram of the ten distinct observations B
+at distinct sites. For 0<r<L, |rho_L(r)|<1: equality in the unit-modulus
+spectral average would require all positive-mass character phases to agree;
+the zero and first modes rule this out away from multiples of L. Thus (3)-(5)
+and the uniform cap in (4) apply for every such positive separation, even
+though raw observation conditioning deteriorates near collision. The exact
+fixed LM006 target is b_M=6/5, b_S=6/5-r^3/6; its conditional mean in (3) is
+G/2-m2(6/5-r^3/12). This is the unscaled physical f_yy(S).
+
+We do not generalize (12) to arbitrary orientations or to nonseparable
+spectra. A positive even joint spectrum proportional to product weights times
+(1+k_x^2 k_y^2/100) has nonzero Cov(Q+m2F,F''); the checker exhibits it.
+If g=0 the residual vanishes. If rho=-1 the target conditional variance is
+zero. At period aliasing rho=1 some unequal-height pins can be incompatible.
+All are excluded from the positive-density statement, not patched by formal
+division by zero. Generic #341 remains useful where separability is absent;
+its higher-jet sufficient condition is not declared false or superseded.
+
+## 6. Reproduction, provenance, and limits
+
+Run `python -B -S test_product_transverse.py` and its `-O` version. Twelve
+methods check independent full 11-observation rational Schur regressions,
+conditional mean values under varied nuisance observations, six-pin difference
+laws, eleven contact jets, residual orthogonality/kernel, and explicit
+nonproduct/negative-correlation/zero-gap/collision cases. The finite models
+use 55 positive product spectral modes and three rational unit-circle phases.
+Their direct covariance sums include derivative signs; the regression matrix
+is constructed without using (2)-(5). This is not a sampled infinite covariance
+or a periodic Gaussian numerical certificate. The 30-control standalone driver
+has six deliberately incorrect alternatives with exact PRODUCT_FAIL reasons.
+Both Python modes and invalid CLI handling are required. Test-first12 missing-
+implementation assertion failures are preserved; no local Lean run is claimed.
+
+This is an author-side result requiring its own nonauthor source-bound review.
+No previous PASS is transferred. General orthogonal Gaussian regression and
+product kernels are prior methodology. Wilson et al., JMLR22(105),2021,
+publication abstract was checked as context only, not as a proof premise.
+No full literature novelty, whole-field event identity, all-mark/orientation
+uniformity, elder/capture/persistence closure, numerical constant/radius,
+independent formal alignment or repaired production gate is asserted. Existing
+scientific registers and the blocked #329 operation are unchanged.
diff --git a/reviews/lm006_product_transverse_20261006/SOURCES.json b/reviews/lm006_product_transverse_20261006/SOURCES.json
new file mode 100644
index 000000000..262656cd2
--- /dev/null
+++ b/reviews/lm006_product_transverse_20261006/SOURCES.json
@@ -0,0 +1,66 @@
+{
+  "schema_version": 1,
+  "scientific_effect": "NONE",
+  "author": {
+    "provider": "OpenAI",
+    "model": "GPT-6 Astra Pro",
+    "session": "lm006-product-residual-r21a-20261006"
+  },
+  "files": {
+    "NOTE.md": {
+      "bytes": 11247,
+      "sha256": "5dfdd74912d7b48bb19eeec3f99ed82b0080d9a00053f525221462cd9346d3be",
+      "git_blob": "1532dad32419e255299cad8e4bdf87519e9397da"
+    },
+    "product_transverse_check.py": {
+      "bytes": 4802,
+      "sha256": "ea78111f70864b0618d5b7520cb0f6098aba23f997a791b226ec0426918dd2e8",
+      "git_blob": "7daa94986628bed0514bfe1ad44d70346f50e346"
+    },
+    "test_product_transverse.py": {
+      "bytes": 4702,
+      "sha256": "397ec775e857556aa568fa45b250625264ac2352873e927dfd4d75dca0878d54",
+      "git_blob": "f6333732e454a6dad5260e4be9445f620d1e25ed"
+    }
+  },
+  "sources": [
+    {
+      "id": "P",
+      "repository": "d6g8k5htny-coder/Math-",
+      "commit": "91821f9262b30ce7684b8ec5f1b4742893dac3d7",
+      "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md",
+      "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2",
+      "slice": "Sections 1-2: actual covariance, pins, spectrum; no global theorem imported"
+    },
+    {
+      "id": "E",
+      "repository": "d6g8k5htny-coder/Math-",
+      "commit": "e31b6ad8356e0760c8a7fb6e816ff640c45176c9",
+      "path": "reviews/lm006_endpoint_extension_20261005/NOTE.md",
+      "git_blob": "551aa563562bc88a19e33d146259c03aa2d318f6",
+      "slice": "Exact raw pins, adjusted endpoint rows and contact coordinates; uniform moment/UI results used conditionally"
+    },
+    {
+      "id": "N",
+      "repository": "d6g8k5htny-coder/Math-",
+      "commit": "5e027afcae8c7bd42a6df8ae2025f82105b3e586",
+      "path": "reviews/lm006_normalizer_stability_20261005/NOTE.md",
+      "git_blob": "5790aaa0332bd8e79b276be1577e4c5f3502eed6",
+      "slice": "Exact typed weight, physical normalization and contact weight"
+    },
+    {
+      "id": "B",
+      "repository": "d6g8k5htny-coder/Math-",
+      "commit": "771913a7dffdc1283e491166d0faa9ec53e1f06a",
+      "path": "reviews/lm006_cubic_sign_band_20261006/NOTE.md",
+      "git_blob": "88dae06c5eefd102239f976513eb5e97c4ac7580",
+      "slice": "Prior sign-band integration and eleven-observation interface; no review transferred"
+    }
+  ],
+  "identity_scope": "Payload SHA256 and Git blobs computed locally. Consumed sources bound by native commit/path/Git blob; no new SHA256 claim for uncopied dependency bytes.",
+  "external_context": {
+    "reference": "Wilson et al., Pathwise Conditioning of Gaussian Processes, JMLR22(105),2021",
+    "read": "publisher abstract/publication record only",
+    "role": "prior methodology, not proof premise"
+  }
+}
diff --git a/reviews/lm006_product_transverse_20261006/product_transverse_check.py b/reviews/lm006_product_transverse_20261006/product_transverse_check.py
new file mode 100644
index 000000000..7daa94986
--- /dev/null
+++ b/reviews/lm006_product_transverse_20261006/product_transverse_check.py
@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Exact finite product-spectrum checks, not a periodic-field certificate or Lean."""
+import argparse
+from fractions import Fraction as F
+from functools import lru_cache
+import json
+import sys
+
+
+def cmul(a,b):
+    return (a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0])
+
+
+def cpow(a,n):
+    if n<0: return cpow((a[0],-a[1]),-n)
+    out=(F(1),F(0))
+    while n:
+        if n&1: out=cmul(out,a)
+        a=cmul(a,a); n//=2
+    return out
+
+
+def spectrum(correlated=False,yvalues=(-2,-1,0,1,2)):
+    p={(x,y):F(1)+F(x*x*y*y,100)*correlated for x in range(-5,6) for y in yvalues}
+    total=sum(p.values()); return {k:w/total for k,w in p.items()}
+
+
+def moments(p):
+    m2=sum(w*y*y for (x,y),w in p.items())
+    m4=sum(w*y**4 for (x,y),w in p.items())
+    return m2,m4,m4-m2*m2
+
+
+@lru_cache(maxsize=4096)
+def primitive(items,z,a,b):
+    sa,xa,ya=a; sb,xb,yb=b
+    if z[0]*z[0]+z[1]*z[1]!=1: raise ValueError('unit-circle rational phase required')
+    ip=cpow((F(0),F(1)),xa+ya-xb-yb)
+    re=im=F(0)
+    for (x,y),w in items:
+        u=cmul(ip,cpow(z,(sa-sb)*x)); scale=w*x**(xa+xb)*y**(ya+yb)
+        re+=scale*u[0]; im+=scale*u[1]
+    if im: raise ValueError('covariance is not real')
+    return re
+
+
+def cov(p,z,a,b):
+    items=tuple(sorted(p.items())); z=tuple(map(F,z))
+    return sum(c*d*primitive(items,z,(s,x,y),(t,u,v))
+               for c,s,x,y in a for d,t,u,v in b)
+
+
+def row(site,dx=0,dy=0): return [(F(1),site,dx,dy)]
+
+
+def rho(p,z): return cov(p,z,row(1),row(0))
+
+
+def residual_cross(p,z,derivative,wrong_sign=False):
+    m2,_,_=moments(p)
+    r=row(1,0,2)+[(m2*(-1 if wrong_sign else 1),1,0,0)]
+    return cov(p,z,r,row(0,*derivative))
+
+
+def residual_covariance(p,z):
+    m2,_,_=moments(p)
+    return cov(p,z,row(1,0,2)+[(m2,1,0,0)],row(0,0,2)+[(m2,0,0,0)])
+
+
+def observations():
+    obs=[row(s,j,0) for s in (0,1) for j in range(3)]
+    obs += [row(s,j,1) for s in (0,1) for j in range(2)]
+    obs += [[(F(1),1,0,2),(F(-1),0,0,2)]]
+    return obs,row(1,0,2)
+
+
+def solve(a,b):
+    n=len(a)
+    if not n or len(b)!=n or any(len(v)!=n for v in a): raise ValueError('square system required')
+    a=[list(map(F,v))+[F(w)] for v,w in zip(a,b)]
+    for j in range(n):
+        k=next((k for k in range(j,n) if a[k][j]),None)
+        if k is None: raise ValueError('singular observations')
+        a[j],a[k]=a[k],a[j]; t=a[j][j]; a[j]=[v/t for v in a[j]]
+        for k in range(n):
+            if k!=j:
+                t=a[k][j]; a[k]=[v-t*w for v,w in zip(a[k],a[j])]
+    return [v[-1] for v in a]
+
+
+def regress(p,z,observed,target):
+    gram=[[cov(p,z,a,b) for b in observed] for a in observed]
+    cross=[cov(p,z,a,target) for a in observed]
+    coefficients=solve(gram,cross)
+    return cov(p,z,target,target)-sum(a*b for a,b in zip(coefficients,cross)),coefficients
+
+
+def require(ok,label):
+    if not ok: raise ValueError(label)
+
+
+def controls(mutant=None):
+    p=spectrum(); m2,_,g=moments(p); z=(F(3,5),F(4,5)); obs,q=observations()
+    v,co=regress(p,z,obs,q); correlation=rho(p,z)
+    require(residual_cross(p,z,(0,0),mutant=='M1')==0,'RESIDUAL_SIGN')
+    require(v==g*(1+correlation)/(1 if mutant=='M2' else 2),'VARIANCE_FACTOR')
+    values=list(map(F,(6,0,1,5,0,-1,0,2,0,-3,1)))
+    mean=sum(a*b for a,b in zip(co,values))
+    require(mean==F(1,2)-(0 if mutant=='M3' else m2*F(11,2)),'MEAN_SHIFT')
+    pins=[obs[j] for j in (0,1,6,3,4,8)]
+    variance,_=regress(p,z,pins,obs[-1])
+    require(variance==(1 if mutant=='M4' else 2)*g*(1-correlation),'DIFFERENCE_VARIANCE')
+    wrong=residual_cross(spectrum(correlated=True),(F(1),F(0)),(2,0))
+    require(wrong==0 if mutant=='M5' else wrong!=0,'PRODUCT_REQUIRED')
+    low=g*(1+rho(p,(F(-1),F(0))))/2
+    require(low>=g/2 if mutant=='M6' else low<g/2,'DENSITY_SIGN_PREMISE')
+    count=6
+    for phase in (z,(F(5,13),F(12,13)),(F(-1),F(0))):
+        for derivative in ((0,0),(1,0),(2,0),(0,1),(1,1)):
+            require(residual_cross(p,phase,derivative)==0,'ORTHOGONALITY'); count+=1
+        require(residual_covariance(p,phase)==g*rho(p,phase),'RESIDUAL_COVARIANCE'); count+=1
+        vr,cr=regress(p,phase,obs,q)
+        require(vr==g*(1+rho(p,phase))/2,'FULL_SCHUR'); count+=1
+        require(sum(a*b for a,b in zip(cr,values))==F(1,2)-m2*F(11,2),'FULL_MEAN'); count+=1
+    return {'controls':count,'arithmetic':'Fraction','scope':'finite spectral Gaussian models; no continuum or Lean execution','scientific_effect':'NONE'}
+
+
+def main():
+    ap=argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--mutant',choices=['M'+str(i) for i in range(1,7)])
+    args=ap.parse_args()
+    try: result=controls(args.mutant)
+    except ValueError as exc:
+        print('PRODUCT_FAIL: '+str(exc),file=sys.stderr); return 1
+    print(json.dumps(result,sort_keys=True)); return 0
+
+if __name__=='__main__': sys.exit(main())
diff --git a/reviews/lm006_product_transverse_20261006/test_product_transverse.py b/reviews/lm006_product_transverse_20261006/test_product_transverse.py
new file mode 100644
index 000000000..f6333732e
--- /dev/null
+++ b/reviews/lm006_product_transverse_20261006/test_product_transverse.py
@@ -0,0 +1,105 @@
+"""Exact finite spectral regressions; not a continuum proof or Lean run."""
+from fractions import Fraction as F
+from pathlib import Path
+import importlib.util
+import itertools
+import json
+import subprocess
+import sys
+import unittest
+
+P = Path(__file__).with_name('product_transverse_check.py')
+PHASES = [(F(3,5),F(4,5)),(F(5,13),F(12,13)),(F(-1),F(0))]
+
+class ProductTests(unittest.TestCase):
+    def setUp(self):
+        self.assertTrue(P.is_file(), 'product-transverse implementation missing')
+        spec=importlib.util.spec_from_file_location('product_check',P)
+        self.m=importlib.util.module_from_spec(spec); spec.loader.exec_module(self.m)
+        self.p=self.m.spectrum()
+
+    def test_moments(self):
+        m2,m4,g=self.m.moments(self.p)
+        self.assertEqual((m2,m4,g),(F(2),F(34,5),F(14,5)))
+
+    def test_residual_orthogonality(self):
+        for z in PHASES:
+            for target in ((0,0),(1,0),(2,0),(0,1),(1,1)):
+                self.assertEqual(self.m.residual_cross(self.p,z,target),0)
+
+    def test_residual_kernel(self):
+        _,_,g=self.m.moments(self.p)
+        for z in PHASES:
+            self.assertEqual(self.m.residual_covariance(self.p,z),g*self.m.rho(self.p,z))
+
+    def test_full_eleven_observation_variance(self):
+        _,_,g=self.m.moments(self.p)
+        for z in PHASES:
+            obs,q=self.m.observations()
+            variance,coeff=self.m.regress(self.p,z,obs,q)
+            self.assertEqual(len(coeff),11)
+            self.assertEqual(variance,g*(1+self.m.rho(self.p,z))/2)
+
+    def test_mean_independent_of_nuisance_values(self):
+        m2,_,_=self.m.moments(self.p)
+        for z in PHASES:
+            obs,q=self.m.observations(); _,co=self.m.regress(self.p,z,obs,q)
+            for shift in (-3,0,4):
+                values=list(map(F,(6,0,shift,5,0,-shift,0,shift,0,2*shift,1)))
+                self.assertEqual(sum(a*b for a,b in zip(co,values)),F(1,2)-m2*F(11,2))
+
+    def test_difference_under_only_six_pins(self):
+        m2,_,g=self.m.moments(self.p)
+        for z in PHASES:
+            obs,q=self.m.observations(); pins=[obs[j] for j in (0,1,6,3,4,8)]
+            diff=obs[-1]; variance,co=self.m.regress(self.p,z,pins,diff)
+            self.assertEqual(variance,2*g*(1-self.m.rho(self.p,z)))
+            self.assertEqual(sum(a*b for a,b in zip(co,map(F,(6,0,0,5,0,0)))),m2)
+
+    def test_contact_eleven_jet_residual(self):
+        obs=[[(F(1),0,j,0)] for j in range(6)]
+        obs += [[(F(1),0,j,1)] for j in range(4)]
+        obs += [[(F(1),0,1,2)]]
+        v,co=self.m.regress(self.p,PHASES[0],obs,[(F(1),0,0,2)])
+        m2,_,g=self.m.moments(self.p)
+        self.assertEqual(v,g)
+        self.assertEqual(co,[-m2]+[F(0)]*10)
+
+    def test_nonproduct_countercontrol(self):
+        p=self.m.spectrum(correlated=True)
+        self.assertNotEqual(self.m.residual_cross(p,(F(1),F(0)),(2,0)),0)
+
+    def test_negative_correlation_not_positive_kernel(self):
+        _,_,g=self.m.moments(self.p)
+        rho=self.m.rho(self.p,PHASES[-1])
+        self.assertLess(rho,0)
+        self.assertLess(g*(1+rho)/2,g/2)
+
+    def test_zero_gap_and_collision_rejected(self):
+        p=self.m.spectrum(yvalues=(-1,1))
+        self.assertEqual(self.m.moments(p)[2],0)
+        obs,q=self.m.observations()
+        with self.assertRaises(ValueError): self.m.regress(p,PHASES[0],obs,q)
+        with self.assertRaises(ValueError): self.m.regress(self.p,(F(1),F(0)),obs,q)
+
+    def test_moment_positivity_and_symmetry(self):
+        self.assertEqual(sum(self.p.values()),1)
+        for (x,y),mass in self.p.items():
+            self.assertGreater(mass,0); self.assertEqual(self.p[-x,-y],mass)
+        for z in PHASES:
+            self.assertEqual(self.m.rho(self.p,z),self.m.rho(self.p,(z[0],-z[1])))
+
+    def test_cli_contract(self):
+        reasons=['RESIDUAL_SIGN','VARIANCE_FACTOR','MEAN_SHIFT','DIFFERENCE_VARIANCE','PRODUCT_REQUIRED','DENSITY_SIGN_PREMISE']
+        baseline=[]
+        for flags in (['-B','-S'],['-B','-O','-S']):
+            p=subprocess.run([sys.executable,*flags,str(P)],capture_output=True,timeout=30)
+            self.assertEqual((p.returncode,p.stderr),(0,b'')); json.loads(p.stdout); baseline.append(p.stdout)
+            for j,reason in enumerate(reasons,1):
+                p=subprocess.run([sys.executable,*flags,str(P),'--mutant','M'+str(j)],capture_output=True,timeout=30)
+                self.assertEqual((p.returncode,p.stdout,p.stderr),(1,b'',('PRODUCT_FAIL: '+reason+'\n').encode()))
+            p=subprocess.run([sys.executable,*flags,str(P),'--mutant','M9'],capture_output=True,timeout=30)
+            self.assertEqual(p.returncode,2)
+        self.assertEqual(*baseline)
+
+if __name__=='__main__': unittest.main()