@trillboards/edge-sdk 0.2.110 → 0.2.113

package/deploy/detector/bench/litert-twin-parity.json

@@ -334,6 +334,31 @@
       "litert_input_layout": "nhwc",
       "measured_at": "2026-08-26",
       "note": "The 22nd twin, added 2026-08-26, and the FIRST whose LiteRT input is NHWC. gh_fall_tonlong had no parity measurement at all until now: upstream ships `Violence` at slot 0 and `violence` at slot 6, normalize_class_name folds them to one name and ModelVocabulary refuses at construction, so neither format could be probed. Both were re-exported from ok.pt (sha256 1e12d89198e28d7c650ba86886c511fecd9f70b9d7f8bf985e76704690e58dd9) with the slots disambiguated by INDEX -- violence_slot0 / violence_slot6 -- which preserves upstream truth and asserts no semantics we have not measured."
+    },
+    {
+      "layout": "anchor_4_plus_nc",
+      "imgsz": 640,
+      "box_abs_max": 1.052759051322937,
+      "units": "normalized",
+      "box_scale_applied": 640.0,
+      "box_residual_px": 0.001220703125,
+      "box_residual_unscaled": 672.7130490541458,
+      "cls_residual": 1.3779020591186963e-07,
+      "pass": true,
+      "reason": "ok",
+      "onnx": "fire_smoke_weslleyskah_11n.onnx",
+      "litert": "fire_smoke_weslleyskah_11n.tflite",
+      "model_id": "fire_smoke_weslleyskah_11n",
+      "box_units": "normalized",
+      "box_scale_to_pixels": 640.0,
+      "litert_input_layout": "nhwc",
+      "litert_sha256": "1511903fece4e163348105cfddb89c657ccc43f1482cde7b090e3f1f7b003c84",
+      "litert_bytes": 9809490,
+      "onnx_sha256": "af8b648caf175edb928eeb3dc6ef73dffc55feaca4097f8133809d8d0ac16419",
+      "onnx_bytes": 10216160,
+      "measured_at": "2026-08-27",
+      "evidence": "twin parity: box residual 0.001221 px after x640, UNSCALED 672.7 px \u2014 the scale is load-bearing, not cosmetic. Class residual 1.38e-07 with no scaling at all. The ONNX half emits PIXELS (max|box| 945.30 over 1,670 real frames, ratio 1.4770) and the LiteRT half NORMALIZED (box_abs_max 1.0528), which is the pair this contract exists for.",
+      "note": "Exported from weslleyskah/fire_smoke_detection_box weights/best.pt (sha256 d2b0be21...) with ultralytics 8.3.201, imgsz 640, opset 19, nms=False. `units` and `box_abs_max` are DERIVED from the LiteRT artifact's own forward pass, not assumed from the layout. Verified twice \u2014 once under the contract at production HEAD and once under PR #13224's derived-units contract \u2014 byte-identical numbers and `pass` under both, because this twin IS normalised, the case the hardcoded x640 already handled. The row does not depend on that PR."
     }
   ]
 }

package/deploy/detector/bench/regrade_control_selection.py

@@ -37,6 +37,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import time
 
 #: Grades whose own note says the set cannot rate a class. Kept in step with
 #: `venue_adjudication.py::LIVENESS_ONLY_GRADES`; the test pins them equal.
@@ -67,7 +68,124 @@ def rateable_controls(per_control: dict, ctlq: dict) -> dict:
     return out
 
 
-def regrade_capability(cap: dict, ctlq: dict, bar: dict) -> dict:
+#: Schemas this tool will read a NEW control rate out of. A rescore artifact is
+#: the ONLY way a control the original screen never scored can reach a verdict
+#: here, and it is admissible for exactly one reason: it was produced by
+#: `venue_adjudication.py`'s OWN rule -- same GRID, same QUIET_MAX_FIRE, same
+#: worst-valid-bucket quiet_t, same bar -- against a control that carries a
+#: contact-sheet grade. Anything else would be an assertion wearing a filename.
+RESCORE_SCHEMAS = ("trillboards.fire-smoke-rescore/1",)
+
+
+def load_rescores(paths) -> dict:
+    """Committed rescore artifacts, keyed by (model, class).
+
+    Returns {(model, class): row}. A file whose schema is not in
+    `RESCORE_SCHEMAS` is REFUSED rather than skipped: a rescore this tool cannot
+    read is a number somebody expected to count, and silently ignoring it is how
+    a verdict stays stale while looking re-derived.
+    """
+    out = {}
+    for path in paths or []:
+        doc = json.load(open(path))
+        if doc.get("schema") not in RESCORE_SCHEMAS:
+            raise SystemExit(
+                "%s has schema %r, which this tool cannot read (known: %s). Refusing rather "
+                "than skipping -- a rescore that is silently ignored leaves the verdict stale "
+                "while the run reports success."
+                % (path, doc.get("schema"), ", ".join(RESCORE_SCHEMAS)))
+        model = (doc.get("artifact") or {}).get("model_id")
+        if not model:
+            raise SystemExit("%s names no artifact.model_id, so its rates belong to nobody" % path)
+        # A rescore may carry caveats that survive its own verdict -- "this clears
+        # the bar AND no live route reaches it" is one fact, not two, and the
+        # record of record is where a reader decides whether to SELL. Carried
+        # rather than restated so there is one home for the measurement.
+        caveats = doc.get("sellability_caveats") or []
+        for cls, e in (doc.get("per_class") or {}).items():
+            out[(model, cls)] = {
+                "control": e["control_set"],
+                "n": e["control_frames"],
+                "rate_025": e["control_rate_025"],
+                "rate_at_quiet_t": e["control_rate_at_quiet_t"],
+                "quiet_t": e["quiet_t"],
+                "source_file": os.path.basename(path),
+                "sellability_caveats": caveats,
+            }
+    return out
+
+
+def apply_rescore(cand: dict, rescores: dict, ctlq: dict):
+    """Merge a rescored control into one candidate's `per_control`.
+
+    Returns (candidate, note). The candidate is a COPY when anything changed.
+
+    THE OFF-TARGET BOUND IS THE WHOLE CARE HERE. `decide()`'s third gate is
+    `off_target_mean <= bar`, and a rescore does not recompute it -- the
+    off-target control sets the original screen fired against are gone. What it
+    can do is INHERIT the committed value, and only in the direction where that
+    is sound: `off_target` is `(scores >= quiet_t).mean()`, which is monotone
+    NON-INCREASING in the threshold, so a value measured at a LOWER quiet_t is a
+    valid UPPER BOUND at a higher one. If the rescore's threshold is BELOW the
+    committed one the bound runs the wrong way, and the row is refused rather
+    than passed on a number nobody measured at that operating point.
+    """
+    key = (cand.get("model"), cand.get("class"))
+    r = (rescores or {}).get(key)
+    if not r:
+        return cand, None
+    grade = (ctlq.get(r["control"]) or {}).get("grade")
+    if grade is None:
+        raise SystemExit(
+            "rescore %s supplies control %r for %s/%s, which has no contact-sheet grade. "
+            "An ungraded set is neither `unusable` nor `liveness_only`, so it would be "
+            "eligible to carry a verdict on nobody's inspection."
+            % (r["source_file"], r["control"], key[0], key[1]))
+    committed_t = cand.get("quiet_t")
+    if committed_t is not None and r["quiet_t"] < committed_t:
+        return cand, {
+            "model": key[0], "class": key[1], "control": r["control"],
+            "refused": ("rescore quiet_t %s is BELOW the committed %s, so the committed "
+                        "off_target_mean is not an upper bound at the rescored operating "
+                        "point and no off-target number exists for it"
+                        % (r["quiet_t"], committed_t)),
+            "source_file": r["source_file"],
+        }
+    merged = dict(cand)
+    # A RATE BELONGS TO THE THRESHOLD IT WAS MEASURED AT. Raising the candidate's
+    # `quiet_t` does not re-measure the controls already in `per_control` -- their
+    # `rate_at_quiet_t` is still the value at the COMMITTED threshold. Because
+    # `(scores >= t).mean()` is monotone non-increasing in t, that number is an
+    # UPPER BOUND at the higher threshold, so reading it as the recall at the new
+    # operating point OVERSTATES recall and can manufacture a PUBLISH. Every entry
+    # is therefore stamped with the threshold that produced it, and selection
+    # admits only the ones measured at the threshold actually applied.
+    merged["per_control"] = {
+        name: dict(row, measured_at_t=row.get("measured_at_t", committed_t))
+        for name, row in (cand.get("per_control") or {}).items()
+    }
+    merged["per_control"][r["control"]] = {
+        "n": r["n"], "rate_025": r["rate_025"], "rate_at_quiet_t": r["rate_at_quiet_t"],
+        "measured_at_t": r["quiet_t"],
+    }
+    merged["quiet_t"] = r["quiet_t"]
+    note = {
+        "model": key[0], "class": key[1], "control": r["control"], "grade": grade,
+        "n": r["n"], "rate_at_quiet_t": r["rate_at_quiet_t"],
+        "quiet_t_committed": committed_t, "quiet_t_rescored": r["quiet_t"],
+        "off_target_mean_inherited": cand.get("off_target_mean"),
+        "off_target_bound_holds_because": (
+            "off_target is (scores >= t).mean(), monotone non-increasing in t, and the "
+            "rescored t (%s) is >= the committed t (%s), so the committed value is an "
+            "upper bound at the rescored operating point"
+            % (r["quiet_t"], committed_t)),
+        "source_file": r["source_file"],
+        "sellability_caveats": r.get("sellability_caveats") or [],
+    }
+    return merged, note
+
+
+def regrade_capability(cap: dict, ctlq: dict, bar: dict, rescores: dict = None) -> dict:
     """Re-apply the bar to one capability using only rateable controls."""
     recall_bar = bar["recall_retention"]
     off_bar = bar["off_target_mean"]
@@ -88,8 +206,11 @@ def regrade_capability(cap: dict, ctlq: dict, bar: dict) -> dict:
             "why": "resolved before any control is read: %s" % (prior,),
         }
 
-    rows, unknown = [], []
+    rows, unknown, rescored, stale_t = [], [], [], []
     for cand in cap["candidates"]:
+        cand, note = apply_rescore(cand, rescores, ctlq)
+        if note:
+            rescored.append(note)
         elided = "_elided" in (cand.get("by_bucket") or {})
         rate = rateable_controls(cand.get("per_control"), ctlq)
         if not rate:
@@ -120,9 +241,39 @@ def regrade_capability(cap: dict, ctlq: dict, bar: dict) -> dict:
                     "elided": elided,
                 })
             continue
+        # Only a control measured at the threshold this candidate is DECIDED at may
+        # carry the verdict. Absent a rescore nothing is stamped and every control
+        # is at the committed threshold, so this is a no-op on the untouched path.
+        applied_t = cand.get("quiet_t")
+        fresh = {k: v for k, v in rate.items()
+                 if v.get("measured_at_t") is None or v["measured_at_t"] == applied_t}
+        stale = {k: v for k, v in rate.items() if k not in fresh}
+        for k, v in sorted(stale.items()):
+            stale_t.append({
+                "model": cand["model"], "class": cand["class"], "control": k,
+                "measured_at_t": v.get("measured_at_t"), "applied_t": applied_t,
+                "rate_at_measured_t": v.get("rate_at_quiet_t"),
+                "why_excluded": ("its rate is an upper bound at the applied threshold, "
+                                 "not a measurement of it, so it may not carry a verdict"),
+            })
+        if not fresh:
+            unknown.append({
+                "model": cand["model"], "class": cand["class"],
+                "decided_on": cand.get("best_control"),
+                "grade": (ctlq.get(cand.get("best_control")) or {}).get("grade"),
+                "why_unknown": ("a rescore moved quiet_t to %s and every rateable control "
+                                "here was measured at a lower threshold (%s), where its rate "
+                                "is only an upper bound -- no control has a rate AT the "
+                                "applied operating point"
+                                % (applied_t,
+                                   ", ".join(sorted(str(v.get("measured_at_t"))
+                                                    for v in stale.values())))),
+                "elided": elided,
+            })
+            continue
         # argmax(rate_025) among the rateable, exactly as the fixed tool does.
-        name = max(rate, key=lambda k: (rate[k]["rate_025"] or 0))
-        row = rate[name]
+        name = max(fresh, key=lambda k: (fresh[k]["rate_025"] or 0))
+        row = fresh[name]
         rows.append({
             "model": cand["model"], "class": cand["class"],
             "control": name, "control_n": row["n"], "grade": row["grade"],
@@ -130,8 +281,13 @@ def regrade_capability(cap: dict, ctlq: dict, bar: dict) -> dict:
             "off_target_mean": cand.get("off_target_mean"),
             "quiet_t": cand.get("quiet_t"),
             "n_valid_negatives": cand.get("n_valid_negatives"),
-            "also_scored": {k: {"n": v["n"], "grade": (ctlq.get(k) or {}).get("grade"),
-                                "rate_at_quiet_t": v["rate_at_quiet_t"]}
+            "also_scored": {k: dict(
+                                {"n": v["n"], "grade": (ctlq.get(k) or {}).get("grade"),
+                                 "rate_at_quiet_t": v["rate_at_quiet_t"]},
+                                **({} if v.get("measured_at_t") in (None, applied_t) else {
+                                    "measured_at_t": v["measured_at_t"],
+                                    "upper_bound_only": ("measured at %s, not the applied %s"
+                                                         % (v["measured_at_t"], applied_t))}))
                             for k, v in (cand.get("per_control") or {}).items() if k != name},
             "source": "recomputed from committed per_control",
         })
@@ -208,6 +364,10 @@ def regrade_capability(cap: dict, ctlq: dict, bar: dict) -> dict:
         "winner": win,
         "candidates_regraded": len(rows),
         "candidates_unknown": blocking,
+        "rescored_controls": rescored,
+        # Never silent: a control dropped for being measured at another
+        # threshold is a stated exclusion, exactly like a withheld model.
+        "stale_threshold_controls": stale_t,
     }
 
 
@@ -260,7 +420,35 @@ def _selftest() -> None:
     measured = regrade_capability(cap("NO MODEL CLEARS BAR"), ctlq, bar)
     assert measured["regraded_decision"] == "NO MODEL CLEARS BAR", measured["regraded_decision"]
 
-    print("selftest OK: idempotent on UNRESOLVED; a measured failure is left alone")
+    # 3. A RESCORE SETTLES AN UNRESOLVED. This is the whole point of --rescore: a
+    #    control added after the screen ran reaches the ladder, and a candidate
+    #    that clears the bar on it turns "not known" into PUBLISH. The elided row
+    #    is still unknown and still reported -- it just cannot block any more,
+    #    which is this tool's own stated monotonicity ("an unknown can only ever
+    #    ADD a passing candidate").
+    ctlq3 = dict(ctlq, fresh={"grade": "good"})
+    rescore = {("m1", "fire"): {"control": "fresh", "n": 72, "rate_025": 0.82,
+                                "rate_at_quiet_t": 0.86, "quiet_t": 0.30,
+                                "source_file": "rescore.json"}}
+    settled = regrade_capability(cap(UNRESOLVED), ctlq3, bar, rescore)
+    assert settled["regraded_decision"] == "PUBLISH", settled["regraded_decision"]
+    assert settled["winner"]["control"] == "fresh", settled["winner"]
+    assert settled["rescored_controls"], "the rescore must be recorded, not silently used"
+    assert settled["changed"] is True
+
+    # 4. A RESCORE AT A LOWER THRESHOLD IS REFUSED. `off_target_mean` is inherited
+    #    from the committed row and is only an UPPER BOUND when the rescored
+    #    threshold is >= the committed one. Below it, no off-target number exists
+    #    at that operating point and passing the row would assert one.
+    low = {("m1", "fire"): {"control": "fresh", "n": 72, "rate_025": 0.82,
+                            "rate_at_quiet_t": 0.86, "quiet_t": 0.10,
+                            "source_file": "rescore.json"}}
+    refused = regrade_capability(cap(UNRESOLVED), ctlq3, bar, low)
+    assert refused["regraded_decision"] == UNRESOLVED, refused["regraded_decision"]
+    assert any("refused" in r for r in refused["rescored_controls"]), refused["rescored_controls"]
+
+    print("selftest OK: idempotent on UNRESOLVED; a measured failure is left alone; "
+          "a rescore settles an unknown; a rescore below the committed threshold is refused")
 
 
 def main() -> None:
@@ -269,7 +457,24 @@ def main() -> None:
         _selftest()
         return
     ap.add_argument("--adjudication", required=True)
-    ap.add_argument("--control-quality", required=True)
+    ap.add_argument("--control-quality", required=True, nargs="+",
+                    help="positive-control-quality-*.json. TAKES A LIST and merges them, later "
+                         "files winning, exactly as venue_adjudication.py does. It read ONE "
+                         "path until 2026-08-27, which is unsafe for the reason that file "
+                         "states about itself: `liveness_only` and `unusable` are both built "
+                         "by MEMBERSHIP, so a set whose grade lives in a file this run did not "
+                         "read falls through both and is eligible to carry a verdict on "
+                         "nobody's inspection. The grades live in DATED files because the "
+                         "2026-08-25 record is pinned by the score cards that cite it, so a "
+                         "set graded later lands in a new file rather than editing that one -- "
+                         "which means a single-path reader was guaranteed to go stale.")
+    ap.add_argument("--rescore", nargs="+", default=None,
+                    help="committed rescore artifact(s) supplying a control the ORIGINAL "
+                         "screen never scored. Admissible only because they are produced by "
+                         "venue_adjudication.py's own rule -- same GRID, same QUIET_MAX_FIRE, "
+                         "same worst-valid-bucket quiet_t, same bar. Without this there is no "
+                         "path for a control added after the screen ran, and a capability "
+                         "whose verdict a later measurement settles stays UNRESOLVED for ever.")
     ap.add_argument("--out", required=True)
     ap.add_argument("--apply", action="store_true",
                     help="also write the corrected verdict back into --adjudication. The "
@@ -278,10 +483,15 @@ def main() -> None:
     args = ap.parse_args()
 
     adj = json.load(open(args.adjudication))
-    ctlq = json.load(open(args.control_quality))
+    ctlq = {}
+    for _q in args.control_quality:
+        for _k, _v in json.load(open(_q)).items():
+            if isinstance(_v, dict) and isinstance(_v.get("grade"), str):
+                ctlq[_k] = _v
     bar = adj["bar"]
 
-    rows = [regrade_capability(c, ctlq, bar) for c in adj["capabilities"]]
+    rescores = load_rescores(args.rescore)
+    rows = [regrade_capability(c, ctlq, bar, rescores) for c in adj["capabilities"]]
     changed = [r for r in rows if r["changed"]]
 
     # The regrade artifact is a record OF A TRANSITION. Once `--apply` has run, the
@@ -313,6 +523,8 @@ def main() -> None:
                          "This re-reads the numbers the adjudication already committed. A "
                          "capability marked `needs_remeasure` has a candidate whose "
                          "rateable-control rate was elided and must come from a re-run.",
+        "control_quality_inputs": sorted(os.path.basename(x) for x in args.control_quality),
+        "rescore_inputs": sorted({os.path.basename(x) for x in (args.rescore or [])}),
         "liveness_only_grades": list(LIVENESS_ONLY_GRADES),
         "unusable_grades": list(UNUSABLE_GRADES),
         "bar": bar,
@@ -327,34 +539,85 @@ def main() -> None:
     }, open(args.out, "w"), indent=1)
 
     if args.apply and changed:
+        # THE WRITER MUST HANDLE BOTH DIRECTIONS. It was built for the WITHDRAWAL
+        # only -- it hardcoded the date `2026-08-26`, always wrote `ships: False`,
+        # and never recorded a winner, because a withdrawal has none. All three
+        # are correct for taking a PUBLISH away and wrong for giving one back,
+        # and a restoration written through the withdrawal's fields would land a
+        # PUBLISH in the record with no model, no control and `ships: False`
+        # beside it -- a verdict a reader cannot act on and a sales claim nobody
+        # can trace to an artifact.
+        today = time.strftime("%Y-%m-%d", time.gmtime())
         by_cap = {r["capability"]: r for r in changed}
         for cap in adj["capabilities"]:
             r = by_cap.get(cap["capability"])
             if not r:
                 continue
             was = dict(cap["decision"])
-            cap["decision"] = {
+            win = r.get("winner") or {}
+            publishes = r["regraded_decision"] == "PUBLISH"
+            if publishes:
+                why_corrected = (
+                    "a control that CAN rate this class was added after the screen ran "
+                    "(`%s`, n=%s, grade %s) and is committed in %s, which computed its rate "
+                    "with venue_adjudication.py's OWN rule -- same GRID, same QUIET_MAX_FIRE, "
+                    "same worst-valid-bucket quiet_t, same bar. Re-applying that bar with the "
+                    "new control in scope clears it. The elided rows stay unknown and cannot "
+                    "block: an unknown can only ever ADD a passing candidate."
+                    % (win.get("control"), win.get("control_n"), win.get("grade"),
+                       ", ".join(sorted({os.path.basename(x) for x in (args.rescore or [])}))
+                       or "a rescore artifact"))
+            else:
+                why_corrected = (
+                    "the verdict rested on `%s` (n=%s, grade %s), a set whose own "
+                    "contact-sheet note says it can only show liveness. Re-applying "
+                    "this run's OWN bar to the controls that can rate a class "
+                    "overturns it." % (was.get("control"), was.get("control_n"),
+                                       r.get("prior_control_grade")))
+            decision = {
                 "decision": r["regraded_decision"],
                 "why": r["why"],
-                # The gate is a promise computed from a recall this verdict no
-                # longer accepts. Keeping it would leave an events-lost figure in
-                # the file with nothing behind it.
+                # NOT re-derived here in either direction, and for the same
+                # reason: `events_lost` / `vlm_calls_saved` are computed by
+                # venue_adjudication.py from the FULL per-frame score matrices
+                # against the whole negative set, which this tool does not hold.
+                # A withdrawal must not keep a promise computed from a recall it
+                # no longer accepts; a restoration must not invent one.
                 "gate": None,
-                "corrected": {
-                    "on": "2026-08-26",
-                    "by": "deploy/detector/bench/regrade_control_selection.py --apply",
-                    "was": was,
-                    "ships": False,
-                    "why_corrected": (
-                        "the verdict rested on `%s` (n=%s, grade %s), a set whose own "
-                        "contact-sheet note says it can only show liveness. Re-applying "
-                        "this run's OWN bar to the controls that can rate a class "
-                        "overturns it." % (was.get("control"), was.get("control_n"),
-                                           r.get("prior_control_grade"))),
-                    "needs_remeasure": r["candidates_unknown"],
-                    "regrade_artifact": args.out,
-                },
+                "gate_is_null_because": (
+                    "the cascade-gate arithmetic is a function of the full score matrices, "
+                    "which this tool does not read. A verdict is derivable from committed "
+                    "rates; a savings promise is not."),
+            }
+            caveats = [c for n in (r.get("rescored_controls") or [])
+                       for c in (n.get("sellability_caveats") or [])]
+            if caveats:
+                # TOP LEVEL, beside the verdict, not buried in `corrected`. This
+                # file is quoted in the sales claim sheet, and a PUBLISH whose
+                # caveat is one level down is a PUBLISH that gets quoted alone.
+                decision["sellability_caveats"] = caveats
+            if publishes:
+                decision.update({
+                    "model": win.get("model"),
+                    "class": win.get("class"),
+                    "control": win.get("control"),
+                    "control_n": win.get("control_n"),
+                    "control_grade": win.get("grade"),
+                    "operating_conf": win.get("quiet_t"),
+                    "n_valid_negatives": win.get("n_valid_negatives"),
+                    "also_scored": win.get("also_scored"),
+                })
+            decision["corrected"] = {
+                "on": today,
+                "by": "deploy/detector/bench/regrade_control_selection.py --apply",
+                "was": was,
+                "ships": publishes,
+                "why_corrected": why_corrected,
+                "needs_remeasure": r["candidates_unknown"],
+                "rescored_controls": r.get("rescored_controls") or [],
+                "regrade_artifact": args.out,
             }
+            cap["decision"] = decision
             cap["changed"] = bool(cap.get("prior_decision_taxi_negatives")
                                   and cap["prior_decision_taxi_negatives"]
                                   != r["regraded_decision"])

package/deploy/detector/bench/twin_parity_contract.py

@@ -74,17 +74,51 @@ def classify_layout(shape, output_names) -> str:
     raise ParityError(f"shape {shape} matches no known detector layout")
 
 
-def box_scale_for(layout: str, imgsz: int) -> float:
+def box_scale_for(layout: str, imgsz: int, box_abs_max: "float | None" = None) -> float:
     """The multiplier that puts LiteRT boxes into the ONNX pixel frame.
 
-    Ultralytics wraps a LiteRT export of a `task=detect` / `end2end=False`
-    model in `_NormalizeCoords`, which divides the four BOX channels by (W, H)
-    and leaves the class channels alone. An end2end head is `end2end=True`, so
-    the wrapper never runs and both runtimes emit pixels.
+    UNITS ARE A PROPERTY OF THE CHECKPOINT, NOT OF THE LAYOUT.
 
-    No layout gets a scale by default. A fall-through to 1.0 would be a guess
-    about an artifact nobody measured, and the wrong guess is silent.
+    This returned `imgsz` for every ANCHOR-layout twin, on the reasoning that
+    ultralytics wraps a `task=detect` / `end2end=False` LiteRT export in
+    `_NormalizeCoords`. That reasoning is disproved by a control: two models
+    exported MINUTES APART in one venv, same tool (8.3.201), same flags
+    (opset 19, imgsz 640, `nms=False`), both classified ANCHOR, measured
+
+        0.0024  (normalized)   and   2.8526  (pixels)
+
+    Same exporter, same settings, same run, opposite units. So no function of
+    (layout, imgsz) can be right in general, and the previous signature could
+    not express the truth even when it knew it.
+
+    `box_abs_max` — the largest absolute box value the LiteRT artifact actually
+    produced on a forward pass — is what settles it. Pass it and the units are
+    DERIVED via `classify_box_units`; the layout is then only a sanity check.
+
+    Omitting it is still allowed for the historical rows in
+    `litert-twin-parity.json`, which were recorded before anything measured
+    box_abs_max — those keep the old layout-derived answer, and the ANCHOR case
+    is exactly where that answer may be wrong. It is deliberately NOT the path
+    a new measurement takes: `verify_litert_twin_parity.py` always passes it,
+    and `verdict()` refuses a new ANCHOR row that arrives without one.
+
+    No layout and no measurement gets a scale by default. A fall-through to 1.0
+    would be a guess about an artifact nobody measured, and the wrong guess is
+    silent.
     """
+    if box_abs_max is not None:
+        # Deferred import: the contract module is stdlib-only so the bare
+        # `detector-service` CI lane can import it, and box_units is too.
+        from box_units import classify_box_units  # noqa: PLC0415
+
+        measured = classify_box_units(box_abs_max, imgsz)
+        if measured["scale_to_pixels"] is None:
+            raise ParityError(
+                f"box units are unmeasured for this artifact: {measured['refusal']}. "
+                "Refusing to assume a scale from the layout — that assumption is "
+                "what the 0.0024-vs-2.8526 control disproved."
+            )
+        return float(measured["scale_to_pixels"])
     if layout == ANCHOR:
         return float(imgsz)
     if layout in (END2END, DETS_LABELS):
@@ -95,14 +129,49 @@ def box_scale_for(layout: str, imgsz: int) -> float:
 def verdict(result) -> "tuple[bool, str]":
     """Does this recorded measurement pass, and if not, which assertion failed."""
     layout = result["layout"]
-    # The scale must be LOAD-BEARING on the anchor layout. If scaling and not
-    # scaling both pass, the model is not telling us which one is right and the
-    # tolerance is doing no work — that is the 640x bug passing its own check.
-    if layout == ANCHOR and result["box_residual_unscaled"] <= BOX_TOL_PX:
+    scale = result.get("box_scale_applied")
+    # THE LOAD-BEARING CHECK APPLIES TO A NORMALISED ARTIFACT, NOT TO A LAYOUT.
+    #
+    # This keyed on `layout == ANCHOR` and read an unscaled match as "the layout
+    # is misread". The control disproved the premise: an ANCHOR twin can emit
+    # PIXELS, and for that artifact an unscaled match is the CORRECT result, not
+    # a misread. Keying it on the layout refused a good artifact and is why the
+    # two models published 2026-08-27 shipped ONNX-only.
+    #
+    # Keyed on the applied scale, the assertion says what it always meant: if we
+    # scaled, the scaling has to matter. A scale of 1.0 is the measured answer
+    # for a pixel artifact and asserts nothing about normalisation.
+    if scale is not None and scale > 1.0 and result["box_residual_unscaled"] <= BOX_TOL_PX:
         return False, (
-            "the imgsz scale changed nothing — an anchor-layout twin whose raw boxes "
-            "already match its ONNX source is not normalised, so the layout is misread"
+            f"the x{scale:g} scale changed nothing — a twin whose RAW boxes already match "
+            "its ONNX source is not normalised, so the measured units are wrong"
+        )
+    # THE ROW MUST ESTABLISH ITS UNITS, BY EITHER ROUTE.
+    #
+    # `box_abs_max` settles it directly. But a row recorded before anything
+    # measured that field can still be decisive: if the scaled residual passes
+    # and the UNSCALED one misses by orders of magnitude, the artifact is
+    # demonstrably normalised — the 22 committed rows carry exactly that shape
+    # (e.g. 0.00087 px scaled against 641.03 unscaled). Demanding the field when
+    # the evidence is already present in another form would refuse good rows to
+    # satisfy a schema, so the check asks whether the units are ESTABLISHED, not
+    # whether a particular key exists.
+    #
+    # What it still refuses is the ambiguous row: no measurement, and two
+    # residuals that do not discriminate. That is a twin whose units nobody knows.
+    if result.get("box_abs_max") is None and result.get("units") is None:
+        scaled = result.get("box_residual_px")
+        unscaled = result.get("box_residual_unscaled")
+        decisive = (
+            scaled is not None and unscaled is not None
+            and scaled <= BOX_TOL_PX and unscaled > BOX_TOL_PX * 100
         )
+        if not decisive:
+            return False, (
+                "twin recorded without box_abs_max, and its scaled/unscaled residuals do "
+                "not discriminate — units were assumed from the layout, and layout does "
+                "not determine units (0.0024 vs 2.8526 control, one venv, one exporter)"
+            )
     if result["box_residual_px"] > BOX_TOL_PX:
         return False, (
             f"box residual {result['box_residual_px']:.4g} px exceeds {BOX_TOL_PX} "