@trillboards/edge-sdk 0.2.110 → 0.2.113

package/deploy/detector/bench/venue_adjudication.py

@@ -130,7 +130,13 @@ CLASS_CONTROL = {
     "gloves": ["ppe_full", "wc_glove"], "glove": ["ppe_full", "wc_glove"], "glove_hand": ["wc_glove", "ppe_full"],
     "apron": ["wc_apron"], "Apron": ["wc_apron"], "hairnet": ["n_hairnet"], "Hairnet": ["n_hairnet"],
     "safety cone": ["n_cone"], "safety_cone": ["n_cone"],
-    "fire_extinguisher": ["n_extinguisher"], "ladder": ["n_ladder"],
+    "fire_extinguisher": ["n_extinguisher"],
+    # `ladder_openimages` (22 frames / 22 scenes, `good`) leads because it is the set that
+    # can rate the class: human-verified Open Images boxes, hand-graded on the pixels.
+    # `n_ladder` is KEPT and stays second so its POOR number remains visible in
+    # `per_control` -- the same reason `fire_generic` was kept after it was demoted. A
+    # control that was refused is evidence about the search, and deleting it hides that.
+    "ladder": ["ladder_openimages", "n_ladder"],
     "person": ["helmet", "ppe_full", "n_crowd"], "worker": ["ppe_full", "helmet", "n_crowd"],
     "human": ["helmet", "ppe_full", "n_crowd"], "head": ["helmet", "n_crowd"],
     "forklift": ["forklift"], "forklift-partial": ["forklift"], "Forklift-Partial": ["forklift"], "yoto": ["forklift"],
@@ -145,8 +151,19 @@ CLASS_CONTROL = {
     "firearm": ["gun_clean", "weapon_cctv"], "knife": ["knife_cctv", "weapon_cctv", "n_knife"],
     "fall": ["fall_cctv"], "fallen": ["fall_cctv"], "fall-detected": ["fall_cctv"],
     "Fall-Detected": ["fall_cctv"], "down": ["fall_cctv"],
-    "door": ["n_door"], "window": ["n_window"], "phone": ["n_phone"], "cell phone": ["n_phone"],
-    "phone_call": ["n_phone"], "mouse": ["n_rodent"], "void": ["n_shelfgap"],
+    "door": ["n_door"], "window": ["n_window"],
+    # `phone_use_meva` (22 frames / 17 fixed cameras, `good`) leads because it is the only
+    # set that can rate this class at all TODAY: `n_phone` is graded `good` but its FRAMES
+    # ARE GONE -- s3://trillboards-media-prod/DEV/regression-corpus/ holds no `n_phone`
+    # prefix, measured 2026-08-27, the same as fire_cctv/fire_generic/wc_spill. `n_phone` is
+    # KEPT and stays second for the same reason `fire_generic` was kept after it was
+    # demoted: its number is in the committed adjudication and deleting the mapping would
+    # hide what the earlier screen scored. The two also answer different questions --
+    # `n_phone` is web stills of people holding smartphones, `phone_use_meva` is fixed CCTV
+    # at 79-690 px of person height, which is the deployment.
+    "phone": ["phone_use_meva", "n_phone"], "cell phone": ["phone_use_meva", "n_phone"],
+    "phone_call": ["phone_use_meva", "n_phone"],
+    "mouse": ["n_rodent"], "void": ["n_shelfgap"],
     "cart": ["wc_cart", "n_trolley"], "trolley": ["wc_cart", "n_trolley"], "shopping_cart": ["wc_cart", "n_trolley"],
     "spill": ["wc_spill", "n_spill"], "Spill": ["wc_spill", "n_spill"],
     "cigarette": ["n_smoking"], "Cigarette": ["n_smoking"], "smoking": ["n_smoking"],
@@ -209,6 +226,33 @@ def assert_every_control_is_graded(pos_sets, ctlq) -> None:
             "would be treated as able to rate a class." % ", ".join(missing))
 
 
+#: The sellable-capability SHAPE contract, read by this tool and by
+#: `.github/scripts/check-sensing-capability-shape.js`. ONE definition, two consumers --
+#: the same posture as `LIVENESS_ONLY_GRADES` above and for the same reason: a tool and a
+#: guard that each carried their own idea of which capabilities a frame can answer would
+#: let a file through that the other would never emit.
+CAPABILITY_SHAPE_PATH = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)),
+    *([os.pardir] * 6), ".github", "contracts", "sensing-capability-shape.json")
+
+
+def load_capability_shape(path: str = CAPABILITY_SHAPE_PATH) -> dict:
+    """`capability -> row` from the shape contract.
+
+    REFUSES rather than degrading when the contract is missing. An adjudication that could
+    not read it would silently fall back to grading every capability as if a frame answered
+    it, which is exactly the state this file is being changed to end: on 2026-08-26 five
+    capabilities came back UNINFORMATIVE under one sentence -- "no usable positive control
+    exists for this class" -- and for four of them that was a statement about a set somebody
+    sourced and refused, while for `shoplifting / theft` it was a statement about a dict that
+    never had an entry. The reader could not tell, and `cctv-detector-tier.md` s10.7 then
+    told them all five needed "an afternoon of labelling".
+    """
+    with open(path) as fh:
+        doc = json.load(fh)
+    return doc.get("capabilities") or {}
+
+
 def normalise_class(name: str) -> str:
     """`labels.py::normalize_class_name`: lower, and `-`/`_` folded to space.
 
@@ -403,6 +447,10 @@ def main() -> None:
                          "`assert_every_control_is_graded` refuses the run rather than "
                          "adjudicating on a set nobody looked at."
     )
+    ap.add_argument("--capability-shape", default=CAPABILITY_SHAPE_PATH,
+                    help="the sellable-capability SHAPE contract. Defaults to "
+                         ".github/contracts/sensing-capability-shape.json; an override "
+                         "exists for replaying an old run, not for the normal path.")
     ap.add_argument("--out", required=True)
     ap.add_argument("--markdown", help="also write the runbook table here")
     args = ap.parse_args()
@@ -420,6 +468,15 @@ def main() -> None:
         for _k, _v in json.load(open(_q)).items():
             if isinstance(_v, dict) and isinstance(_v.get("grade"), str):
                 ctlq[_k] = _v
+    shape_rows = load_capability_shape(args.capability_shape)
+    missing_shape = sorted(set(CAPS) - set(shape_rows))
+    if missing_shape:
+        raise SystemExit(
+            "capability shape undeclared for: %s. Every sellable capability must say "
+            "whether a FRAME can answer it before a firing rate on it means anything; "
+            "add a row to .github/contracts/sensing-capability-shape.json. The "
+            "`sensing-capability-shape` guard refuses the same state statically."
+            % ", ".join(missing_shape))
     index = json.load(open(os.path.join(args.out_dir, "_index.json")))
 
     meta = combo["meta"]
@@ -779,7 +836,7 @@ def main() -> None:
                 c["per_control"] = {}
                 c["gate"] = None
 
-        now = decide(cap, cands)
+        now = decide(cap, cands, shape_rows)
         was, was_model = PRIOR_VERDICT.get(cap, (None, None))
         rows.append({"capability": cap, "n_candidates": len(cands),
                      "prior_decision_taxi_negatives": was,
@@ -790,6 +847,10 @@ def main() -> None:
     json.dump({
         "schema": "trillboards.venue-adjudication/1",
         "negative_set": "venue-phase3-source-2026-08-26",
+        "capability_shape_contract": os.path.relpath(args.capability_shape, os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), *([os.pardir] * 6))),
+        "inexpressible_capabilities": sorted(
+            k for k, v in shape_rows.items() if v.get("expressible_today") is False),
         "supersedes": "the 1,500-frame `production` negative set of 2026-08-25, "
                       "1,494 of which were taxi_rideshare_tv cabin interiors",
         "bar": {
@@ -892,11 +953,32 @@ def _other_controls_clause(win: dict) -> str:
     return "; the same artifact at that threshold keeps " + ", ".join(parts)
 
 
-def decide(cap: str, cands: list) -> dict:
-    """PUBLISH / NO MODEL CLEARS BAR / NOT SCREENABLE, with the reason.
+def decide(cap: str, cands: list, shape_rows: dict = None) -> dict:
+    """NOT A FRAME QUESTION / PUBLISH / NO MODEL CLEARS BAR / NOT SCREENABLE, with the reason.
+
+    Same ladder as the 2026-08-25 screen below the first rung. Only the negative set differs.
 
-    Same ladder as the 2026-08-25 screen. Only the negative set differs.
+    THE FIRST RUNG IS NEW, and it runs before candidates are considered at all, because
+    whether a frame can answer the question is not a fact about which artifacts were sourced.
+    A capability the shape contract declares inexpressible gets `NOT A FRAME QUESTION` and
+    names the substrate it is blocked on -- never `UNINFORMATIVE`, which in this file means
+    "a control was sourced for this class and its contact-sheet grade refuses it" and is a
+    corpus problem an afternoon of labelling fixes.
     """
+    row = (shape_rows or {}).get(cap) or {}
+    if row.get("expressible_today") is False:
+        return {"decision": "NOT A FRAME QUESTION",
+                "shape": row.get("shape"),
+                "frame_observable": row.get("frame_observable"),
+                "substrate_required": row.get("substrate_required"),
+                "n_candidates_screened": len(cands),
+                "why": "this product cannot express the question, so no positive control "
+                       "would make a firing rate here mean anything. Shape is `%s`; the "
+                       "per-frame observable is %s; blocked on `%s`. See "
+                       ".github/contracts/sensing-capability-shape.json for the evidence and "
+                       "docs/runbooks/sensing-model-library.md s1a for the working."
+                       % (row.get("shape"), row.get("frame_observable"),
+                          row.get("substrate_required"))}
     if not cands:
         return {"decision": "NO CANDIDATE",
                 "why": "no sourced artifact declares a class for this capability"}
@@ -909,9 +991,20 @@ def decide(cap: str, cands: list) -> dict:
     live = [c for c in cands if (c["control_rate_025"] or 0) > 0]
     if not live:
         if all(c["best_control"] is None for c in cands):
+            # NAME the sets, because "no usable positive control exists" reads as a claim
+            # about the world and is a claim about two dicts. A class with a control that was
+            # sourced, rendered on a contact sheet and REFUSED is one afternoon of labelling
+            # from a verdict; a class that was never mapped may be a class no frame answers,
+            # and `NOT A FRAME QUESTION` above is where that ends up. Both used to print here.
+            mapped = sorted({n for c in cands
+                             for n in CLASS_CONTROL_N.get(normalise_class(c["class"]), [])})
+            detail = ("the mapped control set(s) %s were all refused by their contact-sheet "
+                      "grade" % ", ".join("`%s`" % m for m in mapped)) if mapped else (
+                     "no control set is mapped to this class in CLASS_CONTROL at all")
             return {"decision": "UNINFORMATIVE",
+                    "controls_mapped": mapped,
                     "why": "no usable positive control exists for this class, so no firing "
-                           "rate here is a finding"}
+                           "rate here is a finding -- %s" % detail}
         return {"decision": "NO MODEL CLEARS BAR",
                 "why": "no candidate fires on its positive control"}
     retained = [c for c in live if (c["control_rate_at_quiet_t"] or 0) >= RECALL_RETENTION_BAR]

package/deploy/detector/bench/verify_litert_twin_parity.py

@@ -53,6 +53,7 @@ import numpy as np
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 
+from box_units import classify_box_units
 from twin_parity_contract import (  # noqa: E402  (same directory)
     ANCHOR,
     BOX_TOL_PX,
@@ -93,12 +94,19 @@ def compare(onnx_out: np.ndarray, litert_out: np.ndarray, layout: str, imgsz: in
         raise ParityError(f"shape mismatch onnx={onnx_out.shape} litert={litert_out.shape}")
     a = litert_out.astype(np.float64)
     b = onnx_out.astype(np.float64)
-    scale = box_scale_for(layout, imgsz)
     box_l, cls_l = split_channels(a, layout)
     box_o, cls_o = split_channels(b, layout)
+    # MEASURE the units off this artifact's own boxes rather than inferring them
+    # from the layout. Two anchor-layout twins exported minutes apart in one venv
+    # measured 0.0024 and 2.8526 — same tool, same flags, opposite units.
+    box_abs_max = float(np.abs(box_l).max()) if box_l.size else 0.0
+    units = classify_box_units(box_abs_max, imgsz)
+    scale = box_scale_for(layout, imgsz, box_abs_max=box_abs_max)
     return {
         "layout": layout,
         "imgsz": imgsz,
+        "box_abs_max": box_abs_max,
+        "units": units["units"],
         "box_scale_applied": scale,
         "box_residual_px": float(np.abs(box_l * scale - box_o).max()),
         "box_residual_unscaled": float(np.abs(box_l - box_o).max()),
@@ -106,23 +114,19 @@ def compare(onnx_out: np.ndarray, litert_out: np.ndarray, layout: str, imgsz: in
     }
 
 
-def verdict(result: dict) -> tuple[bool, str]:
-    # 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 result["layout"] == ANCHOR 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"
-        )
-    if result["box_residual_px"] > BOX_TOL_PX:
-        return False, (
-            f"box residual {result['box_residual_px']:.4g} px exceeds {BOX_TOL_PX} "
-            f"under layout {result['layout']} (scale x{result['box_scale_applied']})"
-        )
-    if result["cls_residual"] > CLS_TOL:
-        return False, f"class residual {result['cls_residual']:.4g} exceeds {CLS_TOL}"
-    return True, "ok"
+# `verdict` is NOT redefined here. It lives in `twin_parity_contract` and is
+# imported above.
+#
+# A second copy stood at this exact spot and SHADOWED the import. It was a
+# faithful duplicate when written, so nothing looked wrong — and then the
+# contract's copy was fixed to derive box units from the artifact while this one
+# kept keying on the layout. The verifier went on refusing the pixel-space
+# anchor twin the fix was written to admit, and the contract's own tests passed
+# the whole time, because they exercise the module that is not the one running.
+#
+# Caught by codex on the very PR that introduced the divergence. One rule, one
+# home: everything that decides pass/fail for a twin is in the contract module,
+# which is also the module the stdlib-only CI lane can import without numpy.
 
 
 def main() -> int:

package/deploy/detector/tests/test_box_units_are_measured.py

@@ -0,0 +1,137 @@
+"""Box units are a property of the CHECKPOINT, not of the layout.
+
+`box_scale_for` returned `imgsz` for every anchor-layout twin, reasoning that
+ultralytics wraps a `task=detect` / `end2end=False` LiteRT export in
+`_NormalizeCoords`. A control disproves the premise: 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
+
+    box residual 0.0024 under the normalized reading, and 2.8526 under the
+    pixel reading — one artifact matches its ONNX twin only when scaled, the
+    other only when not
+
+so no function of (layout, imgsz) can be right in general. (Those two figures are
+RESIDUALS, not box maxima; the maxima below are what `classify_box_units` grades,
+and a normalized artifact's boxes top out near 1.0 while a pixel artifact's
+approach imgsz.) Keying the verdict on
+the layout refused a good artifact, which is why two models published
+2026-08-27 shipped ONNX-only.
+
+Stdlib only, like the rest of this suite, so the bare `detector-service` lane can
+run it with no numpy and no artifact.
+"""
+
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "bench"))
+
+from twin_parity_contract import (  # noqa: E402
+    ANCHOR,
+    BOX_TOL_PX,
+    ParityError,
+    box_scale_for,
+    verdict,
+)
+
+
+def row(**kw):
+    base = {
+        "layout": ANCHOR, "imgsz": 640, "cls_residual": 1e-7,
+        "box_scale_applied": 640.0, "box_residual_px": 0.0008,
+        "box_residual_unscaled": 641.0,
+    }
+    base.update(kw)
+    return base
+
+
+class BoxUnitsAreMeasured(unittest.TestCase):
+    def test_pixel_anchor_twin_passes(self):
+        """The artifact the old rule refused. Anchor layout, PIXEL units."""
+        ok, why = verdict(row(box_abs_max=512.0, units="pixels",
+                              box_scale_applied=1.0, box_residual_unscaled=0.0009,
+                              box_residual_px=0.0009))
+        self.assertTrue(ok, why)
+
+    def test_normalised_anchor_twin_passes(self):
+        ok, why = verdict(row(box_abs_max=0.87, units="normalized"))
+        self.assertTrue(ok, why)
+
+    def test_the_640x_bug_is_still_caught(self):
+        """Scaled by 640 and the scale changed nothing — the original defect."""
+        ok, why = verdict(row(box_abs_max=0.87, units="normalized",
+                              box_residual_unscaled=0.0008))
+        self.assertFalse(ok)
+        self.assertIn("changed nothing", why)
+
+    def test_unmeasured_and_undiscriminating_is_refused(self):
+        """No measurement AND residuals that do not separate = units unknown."""
+        ok, _ = verdict({"layout": ANCHOR, "imgsz": 640, "box_scale_applied": 640.0,
+                         "box_residual_px": 0.0009,
+                         "box_residual_unscaled": BOX_TOL_PX * 2, "cls_residual": 1e-7})
+        self.assertFalse(ok)
+
+    def test_historical_rows_establish_units_without_the_field(self):
+        """The 22 committed rows predate box_abs_max and are still decisive.
+
+        Demanding the field when the evidence is present in another form would
+        refuse good rows to satisfy a schema.
+        """
+        ok, why = verdict({"layout": ANCHOR, "imgsz": 640, "box_scale_applied": 640.0,
+                           "box_residual_px": 0.00087, "box_residual_unscaled": 641.03,
+                           "cls_residual": 2e-6})
+        self.assertTrue(ok, why)
+
+    def test_measurement_overrides_the_layout(self):
+        """Same layout, same imgsz, opposite scales — decided by the artifact."""
+        self.assertEqual(box_scale_for(ANCHOR, 640, box_abs_max=0.87), 640.0)
+        self.assertEqual(box_scale_for(ANCHOR, 640, box_abs_max=512.0), 1.0)
+
+    def test_a_useless_measurement_refuses_rather_than_guessing(self):
+        with self.assertRaises(ParityError):
+            box_scale_for(ANCHOR, 640, box_abs_max=0.0)
+
+    def test_layout_route_survives_for_callers_with_no_measurement(self):
+        self.assertEqual(box_scale_for(ANCHOR, 640), 640.0)
+
+
+class TheVerifierUsesTheContractsVerdict(unittest.TestCase):
+    """One rule, one home — the verifier must not carry its own copy.
+
+    A faithful duplicate of `verdict` sat in verify_litert_twin_parity.py and
+    SHADOWED the import. It was identical when written, so nothing looked wrong;
+    then the contract's copy learned to derive box units from the artifact and
+    this one kept keying on the layout. The verifier went on refusing the
+    pixel-space anchor twin the fix existed to admit — and every contract test
+    passed throughout, because they exercise the module that is not the one
+    running. Caught by review on the PR that introduced the divergence.
+
+    Source-level, deliberately: importing the verifier needs numpy, and this
+    suite runs on the bare `detector-service` lane where numpy is absent.
+    """
+
+    def test_verifier_defines_no_verdict_of_its_own(self):
+        path = os.path.join(
+            os.path.dirname(__file__), "..", "bench", "verify_litert_twin_parity.py"
+        )
+        with open(path, encoding="utf-8") as fh:
+            src = fh.read()
+        self.assertNotIn(
+            "\ndef verdict(", src,
+            "verify_litert_twin_parity.py defines its own verdict(), which shadows the "
+            "imported contract copy — the two then drift silently and the tests exercise "
+            "the wrong one",
+        )
+
+    def test_verifier_imports_the_contract_verdict(self):
+        path = os.path.join(
+            os.path.dirname(__file__), "..", "bench", "verify_litert_twin_parity.py"
+        )
+        with open(path, encoding="utf-8") as fh:
+            src = fh.read()
+        self.assertIn("verdict", src.split("from twin_parity_contract import (")[1][:400])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/deploy/detector/tests/test_regrade_control_selection.py

@@ -29,7 +29,10 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent / "bench")
 
 from regrade_control_selection import (  # noqa: E402
     PRESERVE_ON_BLOCKING,
+    RESCORE_SCHEMAS,
     UNRESOLVED,
+    apply_rescore,
+    load_rescores,
     rateable_controls,
     regrade_capability,
 )
@@ -116,5 +119,110 @@ class TestRegradeControlSelection(unittest.TestCase):
             self.assertEqual(out["status"], "not_affected")
 
 
+
+
+class RescoreReachesTheLadder(unittest.TestCase):
+    """A control added AFTER the screen ran must be able to settle a verdict.
+
+    Without this the tool has no input for a set the original run never scored,
+    so a capability whose verdict a later measurement settles stays `UNRESOLVED`
+    for ever while the registry publishes a model — two stores disagreeing about
+    whether a capability is sellable, which is the state this input exists to
+    end. Proved empirically first: with `fire_firesense` graded `good` and
+    visible to it, the tool still returned UNRESOLVED, because the new control
+    appears in no candidate's `per_control`.
+    """
+
+    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"}}
+    CTLQ3 = dict(CTLQ, fresh={"grade": "good"})
+
+    def test_a_rescore_settles_an_unresolved(self):
+        r = regrade_capability(_cap(UNRESOLVED), self.CTLQ3, BAR, self.RESCORE)
+        self.assertEqual(r["regraded_decision"], "PUBLISH")
+        self.assertEqual(r["winner"]["control"], "fresh")
+        self.assertTrue(r["rescored_controls"], "the rescore must be recorded, not silently used")
+
+    def test_a_rescore_below_the_committed_threshold_is_REFUSED(self):
+        """`off_target_mean` is INHERITED, and only bounds upward.
+
+        It is `(scores >= t).mean()`, monotone non-increasing in t, so a value
+        measured at a LOWER threshold is an upper bound at a higher one. Below
+        the committed threshold the bound runs the wrong way and there is no
+        off-target number at that operating point — passing the row would assert
+        one nobody measured.
+        """
+        low = {("m1", "fire"): dict(self.RESCORE[("m1", "fire")], quiet_t=0.10)}
+        r = regrade_capability(_cap(UNRESOLVED), self.CTLQ3, BAR, low)
+        self.assertEqual(r["regraded_decision"], UNRESOLVED)
+        self.assertTrue(any("refused" in n for n in r["rescored_controls"]))
+
+    def test_an_ungraded_rescored_control_is_refused_not_trusted(self):
+        """An ungraded set falls through both `liveness_only` and `unusable`."""
+        with self.assertRaises(SystemExit):
+            apply_rescore(_cap(UNRESOLVED)["candidates"][0], self.RESCORE, CTLQ)
+
+    def test_a_rescore_never_overturns_a_measured_failure_into_silence(self):
+        """A passing rescore may raise a failure to PUBLISH — that is the point —
+        but it must do so through the ladder, with a winner and a recorded source."""
+        r = regrade_capability(_cap("NO MODEL CLEARS BAR"), self.CTLQ3, BAR, self.RESCORE)
+        self.assertEqual(r["regraded_decision"], "PUBLISH")
+        self.assertEqual(r["rescored_controls"][0]["source_file"], "rescore.json")
+
+    def test_an_unreadable_rescore_schema_is_refused_not_skipped(self):
+        import json as _json
+        import tempfile
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as fh:
+            _json.dump({"schema": "something.else/1"}, fh)
+            bad = fh.name
+        with self.assertRaises(SystemExit):
+            load_rescores([bad])
+
+    def test_a_stale_threshold_control_may_not_carry_the_verdict(self):
+        """THE RATE BELONGS TO THE THRESHOLD IT WAS MEASURED AT.
+
+        A rescore raises the candidate's `quiet_t` but re-measures only its OWN
+        control. Every other rate in `per_control` is still the value at the
+        committed, LOWER threshold, where `(scores >= t).mean()` is an UPPER
+        BOUND — so reading it as the recall at the new operating point overstates
+        recall. Here `big` is stale at 0.90 and the rescored control is a genuine
+        0.30 failure: without per-control threshold tracking `argmax(rate_025)`
+        picks `big` and manufactures a PUBLISH out of a number measured somewhere
+        else.
+        """
+        cap = _cap(UNRESOLVED, with_elided=False)
+        cap["candidates"][0]["per_control"]["big"] = {
+            "n": 9, "rate_025": 0.90, "rate_at_quiet_t": 0.90}
+        weak = {("m1", "fire"): dict(self.RESCORE[("m1", "fire")],
+                                     rate_025=0.30, rate_at_quiet_t=0.30)}
+        r = regrade_capability(cap, self.CTLQ3, BAR, weak)
+        self.assertNotEqual(
+            r["regraded_decision"], "PUBLISH",
+            "a rate measured at the committed threshold was used to clear the bar "
+            "at the higher rescored threshold")
+        stale = r["stale_threshold_controls"]
+        self.assertTrue(stale, "the stale-threshold refusal must be stated, not silent")
+        self.assertEqual(stale[0]["control"], "big")
+        self.assertEqual((stale[0]["measured_at_t"], stale[0]["applied_t"]), (0.25, 0.30))
+
+    def test_a_control_at_the_applied_threshold_still_carries_the_verdict(self):
+        """The positive half: the rescored control IS at the applied threshold,
+        so it decides — this is the path fire and smoke actually take."""
+        r = regrade_capability(_cap(UNRESOLVED, with_elided=False),
+                               self.CTLQ3, BAR, self.RESCORE)
+        self.assertEqual(r["regraded_decision"], "PUBLISH")
+        self.assertEqual(r["winner"]["control"], "fresh")
+
+    def test_without_a_rescore_no_control_is_stamped_stale(self):
+        """The untouched path must be byte-identical — nothing is stamped, so
+        every control remains admissible."""
+        a = regrade_capability(_cap("NO MODEL CLEARS BAR", rateable_rate=0.8), CTLQ, BAR)
+        self.assertEqual(a["regraded_decision"], "PUBLISH")
+
+    def test_the_known_schema_list_is_not_empty(self):
+        self.assertTrue(RESCORE_SCHEMAS)
+
+
 if __name__ == "__main__":
     unittest.main()

package/deploy/detector/trillboards_detector/labels.py

@@ -574,7 +574,29 @@ GH_PPE_VINAYAK_L = ModelVocabulary(
     ),
 )
 
-BUILTIN_VOCABULARIES: "tuple[ModelVocabulary, ...]" = (RFDETR_MEDIUM, GH_FORKLIFT_COMBINE, PPE_VYRA_14CLS_V8M, PPE_CONSTRUCTION_17CLS_V8N, PPE_KILLUMINATI_19CLS_V8S, FALL_1CLS_11X, GH_PPE_VINAYAK_L,)
+#: Fire and Smoke Detector — published 2026-08-27 by
+#: scripts/sensing/publish-sensing-model.js. The class list is the artifact's own
+#: (graph metadata key 'names'); the footprint is MEASURED, 123.7031 MiB after a
+#: probe inference via rusage-maxrss, not an estimate from the file size.
+#: Coordinate space MEASURED, not assumed: max|box channel| = 945.3029 over 1670 real frames; / imgsz 640 = 1.4770. pixels at >= 0.2, normalized at <= 0.02, refused in between.
+FIRE_SMOKE_WESLLEYSKAH_11N_CLASS_NAMES: "MappingProxyType[int, str]" = MappingProxyType({
+    0: "fire",
+    1: "smoke",
+})
+
+FIRE_SMOKE_WESLLEYSKAH_11N = ModelVocabulary(
+    model_name="fire_smoke_weslleyskah_11n",
+    slot_names=FIRE_SMOKE_WESLLEYSKAH_11N_CLASS_NAMES,
+    logit_slots=2,
+    approx_ram_bytes=129712102,
+    onnx_variant=VariantContract(
+        output_layout="anchor_4_plus_nc",
+        box_units="pixels",
+        box_scale_to_pixels=1.0,
+    ),
+)
+
+BUILTIN_VOCABULARIES: "tuple[ModelVocabulary, ...]" = (RFDETR_MEDIUM, GH_FORKLIFT_COMBINE, PPE_VYRA_14CLS_V8M, PPE_CONSTRUCTION_17CLS_V8N, PPE_KILLUMINATI_19CLS_V8S, FALL_1CLS_11X, GH_PPE_VINAYAK_L, FIRE_SMOKE_WESLLEYSKAH_11N,)
 
 
 class ClassIndex:
@@ -668,6 +690,7 @@ class ClassIndex:
 
 
 __all__ = [
+    "FIRE_SMOKE_WESLLEYSKAH_11N",
     "GH_PPE_VINAYAK_L",
     "FALL_1CLS_11X",
     "PPE_KILLUMINATI_19CLS_V8S",