@@ -386,6 +386,13 @@ pub fn omega_total(items: &[Vec<f64>]) -> Option<f64> {
         }
     }
 
+    // A constant item has zero variance: it carries no signal, makes every
+    // scale-relative tolerance below degenerate, and leaves the model
+    // unidentified. Reject rather than absorb it.
+    if (0..k).any(|i| cov[i][i] <= 0.0) {
+        return None;
+    }
+
     // λ_i² averaged over every admissible triad (j,k ≠ i, j ≠ k, σ_jk ≠ 0).
     let mut lambda = vec![0.0f64; k];
     for i in 0..k {
@@ -418,7 +425,13 @@ pub fn omega_total(items: &[Vec<f64>]) -> Option<f64> {
         // has λ² == σ_ii exactly in real arithmetic but lands a few ulps either
         // side of it in f64, and a bare `< 0.0` test would reject a valid model
         // as misfit. Only a violation LARGER than rounding is a real one.
-        let tol = 1e-9 * cov[i][i].abs().max(1.0);
+        // RELATIVE to the item's own variance, with NO absolute floor. A
+        // `.max(1.0)` here is a statement about UNITS: on data whose
+        // covariances are ~1e-16 it makes a 1e-9 tolerance enormous, every
+        // comparison vacuous, and (measured) flipped ω from 0.25 back to
+        // 0.75 purely by rescaling — the SAME defect class as the R²
+        // absolute pivot, fixed there first and left here until review.
+        let tol = 1e-9 * cov[i][i].abs();
         if lam_sq < -tol || !lam_sq.is_finite() {
             return None; // single-factor model violated (negative common variance)
         }
@@ -462,9 +475,7 @@ pub fn omega_total(items: &[Vec<f64>]) -> Option<f64> {
         // A materially-zero covariance means the anchor's or item j's loading
         // is ~0; a ~0-loading item contributes ~nothing to Σλ, so either sign
         // is harmless. Keep +1.
-        let scale = (cov[anchor][anchor].abs() * cov[j][j].abs())
-            .sqrt()
-            .max(1.0);
+        let scale = (cov[anchor][anchor].abs() * cov[j][j].abs()).sqrt();
         if cov[anchor][j] < -1e-9 * scale {
             sign[j] = -1.0;
         }
@@ -477,7 +488,7 @@ pub fn omega_total(items: &[Vec<f64>]) -> Option<f64> {
     // constraints; see the function's doc for what is and is not checked.)
     for i in 0..k {
         for j in (i + 1)..k {
-            let scale = (cov[i][i].abs() * cov[j][j].abs()).sqrt().max(1.0);
+            let scale = (cov[i][i].abs() * cov[j][j].abs()).sqrt();
             let cutoff = 1e-9 * scale;
             if cov[i][j].abs() <= cutoff {
                 continue; // too near zero to carry a sign
@@ -496,7 +507,7 @@ pub fn omega_total(items: &[Vec<f64>]) -> Option<f64> {
     let mut sum_psi = 0.0;
     for i in 0..k {
         let psi = cov[i][i] - lambda[i] * lambda[i];
-        let tol = 1e-9 * cov[i][i].abs().max(1.0);
+        let tol = 1e-9 * cov[i][i].abs();
         if psi < -tol {
             // Heywood case: estimated common variance genuinely exceeds the
             // item's total variance → model misfit, not a reliability value.
@@ -1316,46 +1327,124 @@ mod tests {
         );
     }
 
-    #[test]
-    fn omega_is_invariant_to_a_global_sign_flip() {
-        // The one-factor model is identified only up to a GLOBAL flip, and ω
-        // uses (Σλ)², so flipping every item must leave ω unchanged. This also
-        // proves the sign anchor (s_0 = +1) introduces no arbitrary bias.
-        let items = congeneric_items();
-        let flipped: Vec<Vec<f64>> = items
-            .iter()
-            .map(|it| it.iter().map(|v| -v).collect())
-            .collect();
-        let a = omega_total(&items).unwrap();
-        let b = omega_total(&flipped).unwrap();
-        assert!(approx(a, b, 1e-12), "global flip changed ω: {a} vs {b}");
+    /// ω of [`congeneric_items`], EXACT: `(Σλ)² = 48`, `Σψ = 8/3`, so
+    /// `ω = 48 / (48 + 8/3) = 144/152 = 18/19`. Written as the rational rather
+    /// than a truncated decimal — an 8-digit literal is 1.05e-9 off, which a
+    /// 1e-9 invariance tolerance correctly rejects.
+    const CONGENERIC_OMEGA: f64 = 18.0 / 19.0;
+
+    /// ω of [`zero_anchor_items`], derived exactly below.
+    ///
+    /// With f, e₀, eₐ, e_b mutually orthogonal ±1 vectors of length 8 (each of
+    /// sample variance V = 8/7):
+    ///   loadings        λ = [0, +1, −1, +1]·√V  →  Σλ = √V
+    ///   common variance (Σλ)² = V
+    ///   residuals       ψ = [V, 0, V, V]        →  Σψ = 3V
+    ///   ω = V / (V + 3V) = 0.25
+    /// The pre-fix UNSIGNED implementation returns 0.75 on this fixture, so
+    /// pinning 0.25 is what distinguishes a correct sign fix from "did not
+    /// reject" — a `(0.0..=1.0)` range check blesses both.
+    const ZERO_ANCHOR_OMEGA: f64 = 0.25;
+
+    /// λ = [0, +1, −1, +1]: item 0 carries NO loading, so it is the worst
+    /// possible sign anchor — the fixture that exposes anchor bias.
+    fn zero_anchor_items() -> Vec<Vec<f64>> {
+        let f = [1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0];
+        let e0 = [1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0];
+        let ea = [1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0];
+        let eb = [1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0];
+        vec![
+            e0.to_vec(),                                       // λ = 0
+            f.to_vec(),                                        // λ = +1
+            (0..8).map(|i| -f[i] + ea[i]).collect::<Vec<_>>(), // λ = −1
+            (0..8).map(|i| f[i] + eb[i]).collect::<Vec<_>>(),  // λ = +1
+        ]
     }
 
     #[test]
-    fn omega_sign_anchor_survives_a_zero_loading_item() {
-        // REGRESSION: signs are read from ONE item's covariance row, so the
-        // choice of that row matters. Anchoring on item 0 read every sign off
-        // an all-zero row when item 0 carried no loading — every sign defaulted
-        // to +1, and the consistency check then manufactured conflicts and
-        // REJECTED this valid one-factor dataset (measured: 2 false conflicts).
+    fn omega_is_invariant_to_a_common_rescale() {
+        // REPLACES a vacuous "global sign flip" test (external review).
+        // Negating EVERY item leaves the covariance matrix bit-identical —
+        // `cov(−x,−y) = cov(x,y)` — and `omega_total` consumes only that
+        // matrix, so the old assertion could not fail for any implementation.
+        // It was the workspace's own "assertion implied by the code it tests".
         //
-        // λ = [0, +1, +1, −1] with orthogonal residuals: item 0 is pure noise,
-        // the rest genuinely carry mixed signs. Σλ = 0+1+1−1 = 1, so the
-        // common variance is small but the model is real and must not be
-        // rejected.
-        let f = [1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0];
-        let e0 = [1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0];
-        let e2 = [1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0];
-        let e3 = [1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0];
-        let items = vec![
-            e0.to_vec(),                                         // λ = 0
-            f.to_vec(),                                          // λ = +1
-            (0..8).map(|i| f[i] + e2[i]).collect::<Vec<f64>>(),  // λ = +1
-            (0..8).map(|i| -f[i] + e3[i]).collect::<Vec<f64>>(), // λ = −1
-        ];
-        let w = omega_total(&items)
-            .expect("a valid one-factor set must not be rejected over a weak anchor");
-        assert!((0.0..=1.0).contains(&w), "ω out of range: {w}");
+        // The real invariance: scaling every item by one constant sends
+        // λ → cλ and ψ → c²ψ, leaving the ratio unchanged. This DOES vary the
+        // input, and it is what the absolute `.max(1.0)` tolerance floors
+        // broke — measured, ω flipped 0.25 → 0.75 at scale 1e-8.
+        //
+        // Each fixture is checked against its KNOWN value, not against a
+        // self-computed baseline (external review P1): an implementation that
+        // is consistently WRONG across every scale would satisfy a
+        // self-referential invariance check. Invariance alone never pins a
+        // value.
+        for (fixture, expected) in [
+            (congeneric_items(), CONGENERIC_OMEGA),
+            (zero_anchor_items(), ZERO_ANCHOR_OMEGA),
+        ] {
+            let reference = omega_total(&fixture).expect("baseline must fit");
+            assert!(
+                approx(reference, expected, 1e-9),
+                "baseline ω={reference}, expected {expected}"
+            );
+            for c in [1e-8, 1e-4, 1e-2, 1e2, 1e6] {
+                let scaled: Vec<Vec<f64>> = fixture
+                    .iter()
+                    .map(|it| it.iter().map(|v| v * c).collect())
+                    .collect();
+                let got = omega_total(&scaled)
+                    .unwrap_or_else(|| panic!("scale {c:e} rejected a valid model"));
+                assert!(
+                    approx(got, reference, 1e-9),
+                    "scale {c:e}: ω={got} vs {reference}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn omega_is_invariant_to_item_permutation() {
+        // ω is a property of the item SET, not of their order — but signs are
+        // read from one anchor row, so a bad anchor rule shows up here. The
+        // rotation that puts the ZERO-loading item at index 0 is exactly the
+        // case that broke the previous anchor-on-item-0 implementation.
+        let base = zero_anchor_items();
+        // Pin the absolute value here too — see the rescale test's note.
+        let reference = ZERO_ANCHOR_OMEGA;
+        assert!(approx(omega_total(&base).unwrap(), reference, 1e-9));
+        let k = base.len();
+        for shift in 1..k {
+            let rotated: Vec<Vec<f64>> = (0..k).map(|i| base[(i + shift) % k].clone()).collect();
+            let got = omega_total(&rotated)
+                .unwrap_or_else(|| panic!("rotation by {shift} rejected a valid model"));
+            assert!(
+                approx(got, reference, 1e-9),
+                "shift {shift}: ω={got} vs {reference}"
+            );
+        }
+        // Reverse order too — a different permutation class from rotation.
+        let mut reversed = base.clone();
+        reversed.reverse();
+        assert!(approx(omega_total(&reversed).unwrap(), reference, 1e-9));
+    }
+
+    #[test]
+    fn omega_changes_when_one_item_is_flipped() {
+        // The non-vacuous half of the sign story: flipping ONE item genuinely
+        // changes the model (that item's loading changes sign), so ω MUST
+        // move. A sign-blind implementation would return the same value —
+        // which is precisely the bug this fixture family was built for.
+        let base = congeneric_items();
+        let reference = omega_total(&base).unwrap();
+        let mut flipped = base.clone();
+        flipped[1] = flipped[1].iter().map(|v| -v).collect();
+        let got =
+            omega_total(&flipped).expect("flipping one item is still a valid one-factor model");
+        assert!(
+            (got - reference).abs() > 0.05,
+            "one-item flip must move ω: {got} vs {reference}"
+        );
     }
 
     #[test]
@@ -1418,21 +1507,49 @@ mod tests {
                 "item {i}: ψ would trip the HEYWOOD guard"
             );
         }
-        // …and that the pattern is frustrated from EVERY anchor, so no anchor
-        // choice could rescue it.
-        for anchor in 0..k {
+        // …and that the pattern is genuinely FRUSTRATED, by the LITERAL
+        // specification rather than by the implementation's own procedure
+        // (external review P2). "Reconstruct signs from each anchor row and
+        // look for a conflict" is an implementation-shaped shortcut and is not
+        // the same predicate on sparse sign graphs. The specification is:
+        // does ANY assignment of item signs satisfy every materially non-zero
+        // covariance edge? At k = 4 that is 2^(k−1) = 8 candidates once the
+        // free global flip is fixed — small enough to enumerate exhaustively.
+        let material = |i: usize, j: usize| -> bool {
+            c[i][j].abs() > 1e-9 * (c[i][i].abs() * c[j][j].abs()).sqrt()
+        };
+        let edges: Vec<(usize, usize)> = (0..k)
+            .flat_map(|i| ((i + 1)..k).map(move |j| (i, j)))
+            .filter(|&(i, j)| material(i, j))
+            .collect();
+        // Anti-vacuity: frustration over an empty or near-empty edge set is
+        // meaningless, so the sign graph must actually carry constraints.
+        assert!(
+            edges.len() >= 4,
+            "only {} material edges — frustration would be vacuous",
+            edges.len()
+        );
+        let mut satisfying: Option<Vec<f64>> = None;
+        for mask in 0..(1u32 << (k - 1)) {
             let mut sign = vec![1.0f64; k];
-            for j in 0..k {
-                if j != anchor && c[anchor][j] < 0.0 {
-                    sign[j] = -1.0;
+            for (j, sj) in sign.iter_mut().enumerate().skip(1) {
+                if (mask >> (j - 1)) & 1 == 1 {
+                    *sj = -1.0;
                 }
             }
-            let conflicts = (0..k)
-                .flat_map(|i| ((i + 1)..k).map(move |j| (i, j)))
-                .filter(|&(i, j)| c[i][j] != 0.0 && c[i][j].signum() != sign[i] * sign[j])
-                .count();
-            assert!(conflicts > 0, "anchor {anchor} accepts it — not frustrated");
+            if edges
+                .iter()
+                .all(|&(i, j)| c[i][j].signum() == sign[i] * sign[j])
+            {
+                satisfying = Some(sign);
+                break;
+            }
         }
+        assert!(
+            satisfying.is_none(),
+            "fixture is NOT frustrated — {satisfying:?} satisfies all {} edges",
+            edges.len()
+        );
 
         // Therefore only the sign-consistency guard can produce the rejection.
         assert_eq!(omega_total(&items), None);