fix(formula): a formula constant by algebra is caught before generation, and the gate drops it without a recompute (R4)

Frontline replay (run 5ec4b833c11b, test-mcp 1c5f261): the LLM authored
POLICY_UNDERWRITING.RATE_ON_LINE = WRITTEN_PREMIUM / (WRITTEN_PREMIUM / 0.55),
which is 0.55 on every row by algebra. The Wave 1 identity guard recognises
shapes (X, X*1, 1*X, X/1, X+0) and could not see this one; the column loaded
flat, and the post-load gate recomputed it from the same formula, re-profiled,
and posted a send-blocking repair_failed on top of measure_constant — two
findings and a capped grade for one dropped tile.

Blueprint time — formula.constant_value(), beside alias_target(): decide by
EVALUATION, not symbolic algebra. Probe the formula on twelve seeded random
input vectors (0.2x..5x of each identifier's scale, signed identifiers on both
sides of zero) and call it constant only when every output agrees within
1e-9; a literal has no inputs and is its own constant; anything that does not
parse or evaluate is None (validate() reports those). The blueprint passes its
siblings' scales and signs (_formula_constant), so a clamp or a rounding step
is judged where the data will be, not at 1.0. formula_problems() reports a
constant beside the identity report, so the LLM repair round sees it; the
repair loop's pending filter picks it up next to the alias check, and
_repair_one_formula demotes it with a message that names the formula and says
it is CONSTANT. A nonzero constant is the one thing the author told us — the
magnitude — so it is sampled in a ±25% band around that value (a donor's
scale would have put a 0.55 rate at 15..85); a constant zero (X - X, X * 0)
takes the donor path or is dropped, like any other broken formula.

Gate — a `constant` defect takes the mirrors_other_column route: never a
recompute, so repair_failed cannot be raised for it; a derived constant is
dropped by _should_omit with one measure_constant finding whose detail names
the formula, a base constant is kept on the board and named.

Tests: constant_value cases for X/(X/c), X-X, X*0, X/X, a literal, signed
probing, scale-aware rounding, and the shapes that must stay variable;
blueprint demotion/drop paths for each; gate: a constant derived column
yields exactly one measure_constant finding, no UPDATE, no repair_failed,
and a base constant is kept.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

demoprep_app/dataset/formula.py

@@ -30,6 +30,7 @@ from __future__ import annotations
 import ast
 import math
 import operator
+import random
 from typing import Any, Callable, Iterable, Mapping, MutableSequence
 
 
@@ -582,6 +583,72 @@ def alias_target(formula: str) -> str:
     return node.id if isinstance(node, ast.Name) else ""
 
 
+def constant_value(
+    formula: str,
+    *,
+    scales: Mapping[str, float] | None = None,
+    signed: Iterable[str] = (),
+    samples: int = 12,
+) -> float | None:
+    """The one value this formula produces for EVERY input, or None if it varies.
+
+    Decided by EVALUATION, not algebra. alias_target() recognises the
+    identities an LLM writes by their shape (`X * 1`, `X + 0`); it cannot
+    recognise Frontline's RATE_ON_LINE = WRITTEN_PREMIUM / (WRITTEN_PREMIUM /
+    0.55) (2026-10-20, run 5ec4b833c11b), which is 0.55 on every row by
+    algebra, and there is no end to the shapes that are. So instead: evaluate
+    the formula on several random input vectors and ask whether the output
+    moved. A formula whose output is the same for every vector cannot produce
+    a measure — it is a flat tile — and belongs with the identity guard:
+    caught BEFORE generation, where the repair loop demotes or drops it, not
+    after the load, where the gate recomputed it from the same formula and
+    posted repair_failed on top of measure_constant.
+
+    A literal (`0.55`) has no inputs and is its own constant. Anything that
+    does not parse or cannot be evaluated returns None: validate() reports
+    those, and a constant verdict must never be reached by accident.
+
+    scales: {identifier: typical magnitude}, so a clamp or a rounding step is
+        probed at the measure's own scale — `MIN(MAX(A / B, 0), 1)` sits on
+        its cap for a 0.75 rate only now and then, and `ROUND(X / 1e6, 1)` is
+        a real computation for a seven-figure X and all zeros for a two-figure
+        one. An identifier with no scale is probed around 1.0.
+    signed: identifiers that may be negative. They are probed on both sides of
+        zero, so `MIN(VARIANCE, 0)` — the downside of a signed variance — is
+        not called constant for never having seen a negative input.
+    samples: how many vectors. A true constant is constant on all of them, so
+        every extra vector only makes a FALSE "constant" verdict less likely;
+        a capped ratio can sit on its cap for a few draws in a row, so twelve.
+    """
+    try:
+        node = parse(formula)
+    except FormulaEvaluationError:
+        return None
+    names = sorted(identifiers(formula))
+    magnitudes = {str(name): abs(float(value)) or 1.0 for name, value in (scales or {}).items()}
+    negatives = {str(name) for name in signed}
+    # Seeded by the formula text, so a re-parse of the same blueprint reaches
+    # the same verdict. Each input spreads over 0.2x..5x of its scale.
+    rng = random.Random(f"constant_value:{formula}")
+    seen: float | None = None
+    for i in range(samples if names else 1):
+        values: dict[str, float] = {}
+        for name in names:
+            draw = magnitudes.get(name, 1.0) * math.exp(rng.uniform(math.log(0.2), math.log(5.0)))
+            values[name] = -draw if (name in negatives and i % 2) else draw
+        try:
+            value = float(_eval_node(node, values, measure="", formula=formula, warnings=[]))
+        except (FormulaEvaluationError, ArithmeticError, ValueError):
+            return None
+        if math.isnan(value) or math.isinf(value):
+            return None
+        if seen is None:
+            seen = value
+        elif not math.isclose(value, seen, rel_tol=1e-9, abs_tol=1e-9):
+            return None
+    return seen
+
+
 def _literal(node: ast.AST) -> float | None:
     """The value of a bare numeric literal node, else None."""
     if (isinstance(node, ast.Constant) and isinstance(node.value, (int, float))

demoprep_app/integrations/snowflake/quality_gate.py

@@ -555,13 +555,30 @@ def _column_defects(
             })
             continue
         if s["min"] is not None and s["max"] is not None and s["min"] == s["max"] and row_count > 1:
-            defects.append({
-                "table": table_name, "column": col, "defect": "constant",
-                "detail": f"every row is {s['min']}",
-                "suggestion": (
+            constant_formula = formulas.get(f"{table_name}.{col}", "")
+            if constant_formula:
+                # A derived constant is its formula's doing — Frontline's
+                # RATE_ON_LINE = WRITTEN_PREMIUM / (WRITTEN_PREMIUM / 0.55) is
+                # 0.55 on every row by algebra (2026-10-20). Name the formula:
+                # the fix is in the blueprint, and _should_omit drops the column.
+                detail = (
+                    f"every row is {s['min']} — the formula '{constant_formula}' produced the "
+                    "same value for every row"
+                )
+                suggestion = (
+                    f"{col} = '{constant_formula}' is constant, so it is a flat tile, not a "
+                    f"measure: give {col} a formula whose output changes with its inputs in the "
+                    f"blueprint, or drop {col}"
+                )
+            else:
+                detail = f"every row is {s['min']}"
+                suggestion = (
                     f"give {col} real variation (params.sigma, or a formula whose inputs vary) — "
                     "a constant measure is a flat tile with no story"
-                ),
+                )
+            defects.append({
+                "table": table_name, "column": col, "defect": "constant",
+                "detail": detail, "suggestion": suggestion,
             })
         if is_flag_column(col) and s.get("non_binary"):
             defects.append({
@@ -753,14 +770,19 @@ def _repair_statements(
         ))
         return statements
 
-    if defect["defect"] == "mirrors_other_column":
-        # Never "repair" a mirror by recomputing it: the column IS its formula
-        # over these inputs, so the recompute reproduces the copy, the re-profile
-        # still mirrors, and the run posts repair_failed on top of the mirror
-        # (Humpty Dump, 2026-10-13: three builds in 70 minutes on one measure).
-        # A mirror is a blueprint defect; _OMIT_WORTHY drops the column.
+    if defect["defect"] in ("mirrors_other_column", "constant"):
+        # Never "repair" a mirror or a constant by recomputing it: the column
+        # IS its formula over these inputs, so the recompute reproduces the
+        # copy, the re-profile still shows the defect, and the run posts
+        # repair_failed on top of it — two findings and a capped grade for one
+        # dropped tile (Humpty Dump, 2026-10-13: three builds in 70 minutes on
+        # one mirror; Frontline, 2026-10-20: repair_failed on top of
+        # measure_constant for RATE_ON_LINE = X / (X / 0.55)). Both are
+        # blueprint defects: a mirror and a derived constant are dropped by
+        # _should_omit, a base constant (no formula, nothing to recompute
+        # anyway) is kept on the board and named.
         return []
-    # all_zero / constant: only a formula can fix these.
+    # all_zero: only a formula can fix it.
     return recompute()
 
 
@@ -772,8 +794,9 @@ _REPAIR_ORDER = {"part_exceeds_whole": 0, "flag_not_binary": 1,
 
 
 def _repair_rank(defect: dict) -> int:
-    # Default 3: a pure recompute (all_zero / constant / mirror) runs LAST, so
-    # it reads inputs that have already been bounded or binarised.
+    # Default 3: a pure recompute (all_zero) runs LAST, so it reads inputs that
+    # have already been bounded or binarised. A mirror or a constant has no
+    # repair at all (see _repair_statements) and only takes this rank.
     return _REPAIR_ORDER.get(defect["defect"], 3)
 
 

demoprep_app/scenario/blueprint.py

@@ -31,6 +31,7 @@ from demoprep_app.dataset.formula import (
     difference_pairs as formula_difference_pairs,
     identifiers as formula_identifiers,
     alias_target as formula_alias_target,
+    constant_value as formula_constant_value,
     is_signed as formula_is_signed,
     parse as parse_formula,
     ratio_pairs as formula_ratio_pairs,
@@ -949,11 +950,24 @@ class DemoBlueprint:
         issues: list[str] = []
         for fact in self.facts:
             allowed = {m.name for m in fact.measures}
+            by_name = {m.name: m for m in fact.measures}
             for m in fact.measures:
                 if m.kind != "derived" or not m.formula:
                     continue
-                for problem in validate_formula(m.formula, allowed - {m.name}, measure=m.name):
+                problems = validate_formula(m.formula, allowed - {m.name}, measure=m.name)
+                for problem in problems:
                     issues.append(f"{problem} (fact {fact.name})")
+                if problems:
+                    continue
+                # Valid, computable, and useless: the same value on every row.
+                # Reported here, beside validate()'s identity report, so the
+                # LLM repair round sees it before repair_formulas() demotes it.
+                reason, _ = _constant_reason(m, by_name)
+                if reason:
+                    issues.append(
+                        f"Measure {m.name}: {reason}. Compute something that changes with its "
+                        f"inputs, or drop this measure. (fact {fact.name})"
+                    )
         return issues
 
     def repair_formulas(self) -> list[str]:
@@ -981,11 +995,17 @@ class DemoBlueprint:
                 # board shipped Baseline and Optimized Revenue equal to the cent
                 # on all eight categories. Repair it like any other broken
                 # formula rather than shipping the duplicate silently.
+                # A CONSTANT is the same defect in a shape no identity check
+                # can enumerate: Frontline's RATE_ON_LINE = WRITTEN_PREMIUM /
+                # (WRITTEN_PREMIUM / 0.55) is 0.55 on every row by algebra
+                # (R4, 2026-10-20). Found by evaluating the formula, not by
+                # recognising it — see formula.constant_value().
                 pending = [
                     m for m in fact.measures
                     if m.kind == "derived" and (
                         validate_formula(m.formula, set(by_name) - {m.name}, measure=m.name)
                         or formula_alias_target(m.formula) in (set(by_name) - {m.name})
+                        or _formula_constant(m, by_name) is not None
                     )
                 ]
                 if not pending:
@@ -1813,6 +1833,49 @@ def _alias_reason(measure, by_name: dict) -> str:
     return ""
 
 
+def _measure_scale(measure) -> float:
+    """A positive magnitude typical of this measure, for probing a formula."""
+    params = measure.params or {}
+
+    def number(key: str) -> float:
+        value = params.get(key)
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            return abs(float(value))
+        return 0.0
+
+    low, high = number("low"), number("high")
+    for candidate in (number("mean"), number("sigma"), (low + high) / 2.0, high):
+        if candidate > 0:
+            return candidate
+    return 1.0
+
+
+def _formula_constant(measure, by_name: dict) -> float | None:
+    """The one value `measure.formula` takes on every row, or None if it varies.
+
+    Probes the formula at its siblings' own scales and signs (see
+    formula.constant_value), so a clamp or a rounding step is judged where the
+    data will actually be, not at 1.0.
+    """
+    siblings = {name: m for name, m in by_name.items() if name != measure.name}
+    return formula_constant_value(
+        measure.formula,
+        scales={name: _measure_scale(m) for name, m in siblings.items()},
+        signed={name for name, m in siblings.items() if getattr(m, "signed", False)},
+    )
+
+
+def _constant_reason(measure, by_name: dict) -> tuple[str, float | None]:
+    """(why, value) when this measure's formula is constant, else ("", None)."""
+    value = _formula_constant(measure, by_name)
+    if value is None:
+        return "", None
+    return (
+        f"formula '{measure.formula}' is CONSTANT — it evaluates to {value:g} whatever its "
+        "inputs are, so it would ship a flat column with no story"
+    ), value
+
+
 def _repair_one_formula(fact, measure, by_name: dict) -> list[str]:
     """Case-fix, demote, or drop ONE uncomputable derived measure."""
     siblings = {name for name in by_name if name != measure.name}
@@ -1820,7 +1883,11 @@ def _repair_one_formula(fact, measure, by_name: dict) -> list[str]:
     # 0. A copy is not broken, so the case-fix path below cannot help it and the
     #    message must not claim it is "not computable". Go straight to demotion,
     #    which gives the measure its own variation off the source it copied.
+    #    A CONSTANT is the same: valid, computable, and a flat column.
     alias_reason = _alias_reason(measure, by_name)
+    constant_reason, constant = ("", None) if alias_reason else _constant_reason(measure, by_name)
+    why = (alias_reason or constant_reason
+           or f"formula '{measure.formula}' is not computable in fact {fact.name}")
 
     # 1. case-only mismatches are a rewrite, not a loss
     upper_map = {name.upper(): name for name in siblings}
@@ -1834,11 +1901,35 @@ def _repair_one_formula(fact, measure, by_name: dict) -> list[str]:
             import re as _re
             rewritten = _re.sub(rf"\b{_re.escape(token)}\b", target, rewritten)
             renames.append(f"{token}->{target}")
-    if not alias_reason and renames and not validate_formula(rewritten, siblings, measure=measure.name):
+    if not (alias_reason or constant_reason) and renames and not validate_formula(
+        rewritten, siblings, measure=measure.name
+    ):
         old = measure.formula
         measure.formula = rewritten
         return [f"{measure.name}: formula '{old}' -> '{rewritten}' ({', '.join(renames)})"]
 
+    # 1b. A formula constant at a NONZERO value has told us one thing only: the
+    #     magnitude its author had in mind. Frontline's RATE_ON_LINE =
+    #     WRITTEN_PREMIUM / (WRITTEN_PREMIUM / 0.55) means "about 0.55", and a
+    #     donor's scale (the premium, six figures) would put that rate at
+    #     15..85. Sample around the value the formula produced instead; the
+    #     bound pass in harden() still applies the measure's own range. A
+    #     constant ZERO (`X - X`, `X * 0`) says nothing about magnitude and
+    #     takes the donor path below like any other broken formula.
+    if constant:
+        low, high = sorted((round(constant * 0.75, 6), round(constant * 1.25, 6)))
+        measure.kind = "base"
+        measure.formula = ""
+        measure.share_of = ""
+        measure.distribution = "uniform"
+        measure.signed = constant < 0
+        measure.params = {"low": low, "high": high}
+        return [
+            f"{measure.name}: {constant_reason} -> base measure sampled in {low:g}..{high:g}, "
+            "around the one value the formula produced. The tile stays on the board; the "
+            "value is sampled, not derived."
+        ]
+
     # 2. demote to a base measure scaled off a sibling the formula referenced
     donor = _pick_donor(measure, by_name)
     if donor is not None:
@@ -1893,7 +1984,7 @@ def _repair_one_formula(fact, measure, by_name: dict) -> list[str]:
                 measure.params = {"low": round(low, 6), "high": round(high, 6)}
                 shape = f"rate in {measure.params['low']}..{measure.params['high']}"
             return [
-                f"{measure.name}: " + (alias_reason or f"formula '{old}' is not computable in fact {fact.name}") + " "
+                f"{measure.name}: {why} "
                 f"-> base measure on {donor.name}'s scale ({shape}). "
                 "The tile stays on the board; the value is sampled, not derived."
             ]
@@ -1913,7 +2004,7 @@ def _repair_one_formula(fact, measure, by_name: dict) -> list[str]:
             measure.params = {"mean": spread, "sigma": 0.5}
             shape = f"mean {spread}"
         return [
-            f"{measure.name}: " + (alias_reason or f"formula '{old}' is not computable in fact {fact.name}") + " "
+            f"{measure.name}: {why} "
             f"-> base measure scaled off {donor.name} ({shape}). "
             "The tile stays on the board; the value is sampled, not derived."
         ]
@@ -1929,13 +2020,13 @@ def _repair_one_formula(fact, measure, by_name: dict) -> list[str]:
         measure.params = {"mean": 100.0, "sigma": 0.5}
         measure.share_of = ""
         return [
-            f"{measure.name}: formula '{old}' is not computable and it is the only measure in "
-            f"fact {fact.name} -> sampled base measure, so the fact still has something to chart."
+            f"{measure.name}: {why}, and it is the only measure in fact {fact.name} -> sampled "
+            "base measure, so the fact still has something to chart."
         ]
     fact.measures = [m for m in fact.measures if m.name != measure.name]
     return [
-        f"{measure.name}: dropped — formula '{old}' is not computable in fact {fact.name} "
-        "and no sibling measure to scale it off. The demo ships without this measure."
+        f"{measure.name}: dropped — {why}, and no sibling measure to scale it off. "
+        "The demo ships without this measure."
     ]
 
 

tests/test_blueprint_measure_hardening.py

@@ -384,3 +384,93 @@ def test_each_formula_repair_is_reported_exactly_once():
     bp.autorepair()
     repairs = [f for f in bp.metadata.get("autorepairs", []) if "MARGIN_ERROR" in f]
     assert len(repairs) == 1, repairs
+
+
+# --- constant formulas are demoted BEFORE generation (findings triage R4) ------
+# Frontline (2026-10-20, run 5ec4b833c11b): RATE_ON_LINE = WRITTEN_PREMIUM /
+# (WRITTEN_PREMIUM / 0.55) is 0.55 on every row by algebra. The identity guard
+# did not recognise it, the column loaded flat, and the post-load gate recomputed
+# it from the same formula and posted repair_failed on top of measure_constant.
+# The repair loop now catches it where the identity guard lives.
+
+
+def _frontline(formula, *, fmt="pct"):
+    return _blueprint([
+        {"name": "WRITTEN_PREMIUM", "fmt": "currency", "params": {"mean": 250000}},
+        {"name": "POLICY_LIMIT", "fmt": "currency", "params": {"mean": 1000000}},
+        {"name": "RATE_ON_LINE", "kind": "derived", "formula": formula, "fmt": fmt},
+    ], insights=_insights("WRITTEN_PREMIUM"))
+
+
+def test_a_formula_constant_by_algebra_is_demoted_around_its_value_before_generation():
+    bp = _frontline("WRITTEN_PREMIUM / (WRITTEN_PREMIUM / 0.55)")
+    # The LLM repair round sees it, beside the identity report.
+    problems = bp.formula_problems()
+    assert len(problems) == 1 and "RATE_ON_LINE" in problems[0]
+    assert "CONSTANT" in problems[0] and "0.55" in problems[0]
+
+    fixes = bp.repair_formulas()
+    m = _measure(bp, "RATE_ON_LINE")
+    assert m.kind == "base" and m.formula == ""
+    # Sampled around the value the formula produced, not off the premium's scale.
+    assert m.distribution == "uniform"
+    assert m.params["low"] < 0.55 < m.params["high"]
+    assert 0.3 <= m.params["low"] and m.params["high"] <= 0.8
+    fix = next(f for f in fixes if f.startswith("RATE_ON_LINE"))
+    assert "WRITTEN_PREMIUM / (WRITTEN_PREMIUM / 0.55)" in fix
+    assert "CONSTANT" in fix and "0.55" in fix and "not computable" not in fix
+    assert bp.formula_problems() == []
+
+    rows = BlueprintEngine().generate(bp, 500).table_map()["LOAD_TRANSACTION"].rows
+    values = {round(r["RATE_ON_LINE"], 6) for r in rows}
+    assert len(values) > 1, "the demoted measure must vary row to row"
+    assert all(0.0 < v < 1.0 for v in values)
+
+
+def test_a_literal_formula_is_constant_too():
+    bp = _frontline("0.55")
+    # from_dict() already hardened the pct formula into its MIN/MAX wrap; the
+    # guard judges the formula as it stands and names that.
+    assert _measure(bp, "RATE_ON_LINE").formula == "MIN(MAX(0.55, 0), 1)"
+    fixes = bp.repair_formulas()
+    m = _measure(bp, "RATE_ON_LINE")
+    assert m.kind == "base" and m.distribution == "uniform"
+    assert m.params["low"] < 0.55 < m.params["high"]
+    assert any("'MIN(MAX(0.55, 0), 1)' is CONSTANT" in f and "0.55 whatever" in f for f in fixes)
+
+
+def test_a_formula_constant_at_zero_takes_the_donor_path_and_says_why():
+    # X - X and X * 0 say nothing about magnitude, so they demote off a sibling
+    # like any other broken formula — a difference signed and centred on zero.
+    bp = _frontline("WRITTEN_PREMIUM - WRITTEN_PREMIUM", fmt="currency")
+    fixes = bp.repair_formulas()
+    m = _measure(bp, "RATE_ON_LINE")
+    assert m.kind == "base" and m.formula == "" and m.signed is True
+    fix = next(f for f in fixes if f.startswith("RATE_ON_LINE"))
+    assert "WRITTEN_PREMIUM - WRITTEN_PREMIUM" in fix and "CONSTANT" in fix
+    assert "not computable" not in fix
+
+    bp = _frontline("WRITTEN_PREMIUM * 0", fmt="currency")
+    fixes = bp.repair_formulas()
+    m = _measure(bp, "RATE_ON_LINE")
+    assert m.kind == "base" and m.signed is False
+    assert any("WRITTEN_PREMIUM * 0" in f and "CONSTANT" in f for f in fixes)
+
+
+def test_a_constant_formula_with_nothing_to_scale_off_is_dropped_and_named():
+    bp = _blueprint([
+        {"name": "BASE_AMOUNT", "fmt": "currency", "params": {"mean": 100}},
+        {"name": "DOUBLED", "kind": "derived", "formula": "BASE_AMOUNT * 2"},
+        {"name": "ZEROED", "kind": "derived", "formula": "DOUBLED - DOUBLED"},
+    ], insights=_insights("BASE_AMOUNT"))
+    fixes = bp.repair_formulas()
+    assert {m.name for m in bp.facts[0].measures} == {"BASE_AMOUNT", "DOUBLED"}
+    fix = next(f for f in fixes if f.startswith("ZEROED"))
+    assert "dropped" in fix and "DOUBLED - DOUBLED" in fix and "CONSTANT" in fix
+
+
+def test_a_real_formula_is_left_alone_by_the_constant_guard():
+    bp = _frontline("WRITTEN_PREMIUM / POLICY_LIMIT")
+    assert bp.formula_problems() == []
+    assert bp.repair_formulas() == []
+    assert _measure(bp, "RATE_ON_LINE").kind == "derived"

tests/test_measure_formula.py

@@ -13,6 +13,7 @@ import pytest
 from demoprep_app.dataset.formula import (
     FormulaEvaluationError,
     alias_target,
+    constant_value,
     evaluate,
     identifiers,
     ratio_pairs,
@@ -141,6 +142,71 @@ def test_a_real_computation_is_not_an_identity(formula):
     assert validate(formula, {"RENTAL_DAYS", "IDLE_DAYS"}, measure="DAYS_ON_SITE") == []
 
 
+# --- constant formulas cannot produce a measure (findings triage 2026-10-20, R4)
+#
+# Frontline's RATE_ON_LINE = WRITTEN_PREMIUM / (WRITTEN_PREMIUM / 0.55) is 0.55
+# on every row by algebra. The identity guard above recognises shapes; it
+# cannot enumerate every algebraic identity, so constant_value() EVALUATES the
+# formula on random inputs and asks whether the output moved. It sits beside
+# alias_target() so there is one place for "this formula cannot produce a
+# measure", and the blueprint repair loop demotes or drops it before generation.
+
+
+@pytest.mark.parametrize("formula, value", [
+    ("WRITTEN_PREMIUM / (WRITTEN_PREMIUM / 0.55)", 0.55),      # the Frontline case
+    ("WRITTEN_PREMIUM - WRITTEN_PREMIUM", 0.0),
+    ("WRITTEN_PREMIUM * 0", 0.0),
+    ("0.55", 0.55),                                            # a literal: no inputs at all
+    ("WRITTEN_PREMIUM / WRITTEN_PREMIUM", 1.0),
+    ("(WRITTEN_PREMIUM + POLICY_LIMIT) * 0 + 7", 7.0),
+    ("ROUND(WRITTEN_PREMIUM * 0.55 / WRITTEN_PREMIUM, 2)", 0.55),
+])
+def test_a_formula_that_cannot_vary_is_reported_with_its_value(formula, value):
+    assert constant_value(formula) == pytest.approx(value)
+
+
+@pytest.mark.parametrize("formula", [
+    "WRITTEN_PREMIUM / POLICY_LIMIT", "WRITTEN_PREMIUM * 0.55", "WRITTEN_PREMIUM - POLICY_LIMIT",
+    "MIN(MAX(WRITTEN_PREMIUM / POLICY_LIMIT, 0), 1)", "ROUND(WRITTEN_PREMIUM / POLICY_LIMIT, 2)",
+    "1 / WRITTEN_PREMIUM", "ABS(WRITTEN_PREMIUM)", "COALESCE(WRITTEN_PREMIUM, 0)",
+    "WRITTEN_PREMIUM * 1",                     # an identity varies: that is alias_target's case
+])
+def test_a_formula_that_varies_with_its_inputs_is_not_constant(formula):
+    assert constant_value(formula) is None
+
+
+def test_constant_detection_is_by_evaluation_so_it_never_guesses():
+    # Not parseable, or not evaluable: validate() reports those; a constant
+    # verdict is only ever reached on a formula that actually ran.
+    assert constant_value("this is not ( a formula") is None
+    assert constant_value("SQRT(WRITTEN_PREMIUM) * 0") is None
+    assert constant_value("") is None
+    # Deterministic for the same formula text: a re-parse reaches the same verdict.
+    assert constant_value("WRITTEN_PREMIUM / POLICY_LIMIT") is None
+    assert constant_value("WRITTEN_PREMIUM / (WRITTEN_PREMIUM / 0.55)") == pytest.approx(0.55)
+
+
+def test_a_signed_input_is_probed_on_both_sides_of_zero():
+    # MIN(V, 0) is the downside of a signed variance. Probed only with positive
+    # inputs it would read as constant 0 and lose the tile.
+    assert constant_value("MIN(BUDGET_VARIANCE, 0)", signed={"BUDGET_VARIANCE"}) is None
+    # ...while a formula that really is constant on both sides stays caught.
+    assert constant_value("MAX(BUDGET_VARIANCE, 0) * MIN(BUDGET_VARIANCE, 0)",
+                          signed={"BUDGET_VARIANCE"}) == pytest.approx(0.0)
+
+
+def test_a_rounding_step_is_judged_at_the_measures_own_scale():
+    # ROUND(X / 1e6, 1) is a real computation for a seven-figure premium and a
+    # column of zeros for a two-figure one — the scale decides, not the shape.
+    formula = "ROUND(WRITTEN_PREMIUM / 1000000, 1)"
+    assert constant_value(formula, scales={"WRITTEN_PREMIUM": 5_000_000}) is None
+    assert constant_value(formula, scales={"WRITTEN_PREMIUM": 50}) == pytest.approx(0.0)
+    # The same for whole hundreds: a six-figure premium varies, an unscaled
+    # probe around 1.0 does not — which is why the blueprint passes its scales.
+    assert constant_value("ROUND(WRITTEN_PREMIUM / 100, 0)", scales={"WRITTEN_PREMIUM": 250000}) is None
+    assert constant_value("ROUND(WRITTEN_PREMIUM / 100, 0)") == pytest.approx(0.0)
+
+
 # --- helpers ----------------------------------------------------------------
 
 

tests/test_quality_gate.py

@@ -895,6 +895,78 @@ def test_a_mirror_is_omitted_without_a_recompute_and_names_the_identity():
     assert "not a measure of" not in defect["suggestion"]
 
 
+def _frontline_cursor(*, rate_formula_known: bool):
+    """Frontline's POLICY_UNDERWRITING with RATE_ON_LINE flat at 0.55.
+
+    Five measures, so one dropped column (20%) stays under the 25% abort line.
+    """
+    money = lambda lo, hi, avg: {"non_zero": 4000, "min": lo, "max": hi, "avg": avg}
+    cursor = FakeCursor(
+        columns_rows=[
+            ("POLICY_UNDERWRITING", "WRITTEN_PREMIUM_USD", "NUMBER(16,2)"),
+            ("POLICY_UNDERWRITING", "POLICY_LIMIT_USD", "NUMBER(16,2)"),
+            ("POLICY_UNDERWRITING", "LOSS_PAID_USD", "NUMBER(16,2)"),
+            ("POLICY_UNDERWRITING", "EXPENSE_USD", "NUMBER(16,2)"),
+            ("POLICY_UNDERWRITING", "RATE_ON_LINE", "NUMBER(16,4)"),
+        ],
+        profiles={"POLICY_UNDERWRITING": [profile_row(4000, [
+            ("WRITTEN_PREMIUM_USD", money(1200.0, 980000.0, 142000.0)),
+            ("POLICY_LIMIT_USD", money(10000.0, 5000000.0, 910000.0)),
+            ("LOSS_PAID_USD", money(0.0, 640000.0, 61000.0)),
+            ("EXPENSE_USD", money(90.0, 88000.0, 12500.0)),
+            ("RATE_ON_LINE", {"non_zero": 4000, "min": 0.55, "max": 0.55, "avg": 0.55}),
+        ])]},
+        part_whole={"POLICY_UNDERWRITING": [(0,), (0,)]},
+    )
+    formulas = (
+        {"POLICY_UNDERWRITING.RATE_ON_LINE": "WRITTEN_PREMIUM_USD / (WRITTEN_PREMIUM_USD / 0.55)"}
+        if rate_formula_known else {}
+    )
+    return cursor, formulas
+
+
+def test_a_constant_derived_column_is_omitted_without_a_recompute():
+    """Frontline (2026-10-20, run 5ec4b833c11b): RATE_ON_LINE = WRITTEN_PREMIUM
+    / (WRITTEN_PREMIUM / 0.55) is 0.55 on every row. The gate recomputed it from
+    the same formula, re-profiled, and posted repair_failed on top of
+    measure_constant — two findings and a capped grade for one dropped tile."""
+    cursor, formulas = _frontline_cursor(rate_formula_known=True)
+    profile = run_measure_quality_gate(FakeConnection(cursor), "FRO_sch", formulas=formulas)
+
+    assert [d["defect"] for d in profile["defects"]] == ["constant"]
+    assert cursor.sql_of_kind("UPDATE") == [], "a constant is never recomputed"
+    assert profile["repair_failures"] == [] and profile["repairs"] == []
+    assert [o["column"] for o in profile["omissions"]] == ["RATE_ON_LINE"]
+    assert cursor.sql_of_kind("ALTER") == [
+        'ALTER TABLE "FRO_sch"."POLICY_UNDERWRITING" DROP COLUMN "RATE_ON_LINE"'
+    ]
+    assert profile["failures"] == []
+    # Exactly one finding for the dropped measure — and it is not repair_failed.
+    findings = [f for f in profile["findings"] if f["severity"] != "info"]
+    assert [f["code"] for f in findings] == ["measure_constant"]
+    assert findings[0]["measure"] == "RATE_ON_LINE" and findings[0]["extra"]["omitted"] is True
+    assert "DROPPED" in findings[0]["message"]
+    defect = profile["defects"][0]
+    assert "WRITTEN_PREMIUM_USD / (WRITTEN_PREMIUM_USD / 0.55)" in defect["detail"]
+    assert "is constant" in defect["suggestion"] and "blueprint" in defect["suggestion"]
+
+
+def test_a_constant_base_column_is_kept_on_the_board_and_named():
+    # No formula: nothing to recompute and nothing to blame the blueprint for —
+    # a flat attribute is reported and kept, not dropped.
+    cursor, formulas = _frontline_cursor(rate_formula_known=False)
+    profile = run_measure_quality_gate(FakeConnection(cursor), "FRO_sch", formulas=formulas)
+
+    assert [d["defect"] for d in profile["defects"]] == ["constant"]
+    assert cursor.sql_of_kind("UPDATE") == [] and cursor.sql_of_kind("ALTER") == []
+    assert profile["repair_failures"] == [] and profile["omissions"] == []
+    assert [d["column"] for d in profile["failures"]] == ["RATE_ON_LINE"]
+    findings = [f for f in profile["findings"] if f["severity"] != "info"]
+    assert [f["code"] for f in findings] == ["measure_constant"]
+    assert findings[0]["extra"]["omitted"] is False
+    assert profile["defects"][0]["detail"] == "every row is 0.55"
+
+
 def test_a_hollow_difference_names_the_input_that_contributed_nothing():
     from demoprep_app.integrations.snowflake.quality_gate import _mirror_explanation