From 4df2efc2be857328b1b2990db739b55e772374ee Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Sat, 14 Nov 2026 08:01:12 -0400 Subject: [PATCH] census-watch: UNCOVERED names the uploader count, because four models of one class is one mapping decision (engine#2427) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `REMOTE-CODE` has printed `from N uploader(s)` since the spread rule landed; both `UNCOVERED` branches did not. So: !! UNCOVERED SegaForCausalLM (new class): 4 model(s), e.g. the123manaic/Sega-7.0-Singularity-Infinity reads like four people asking for a family, and it is one org's uploads. The count is a claim about **the registry's next entry**, and four models under one org is **one** mapping decision -- a registry that grows an entry per model count rather than per uploading org grows entries nobody asked for. Now: !! UNCOVERED SegaForCausalLM (new class): 4 model(s) from 2 uploader(s), e.g. ... !! UNCOVERED ReviewedForCausalLM (reviewed, not an alias — docs/arch-gaps.md): 2 model(s) from 1 uploader(s), e.g. ... The mechanism was already there -- `classify()` groups by class and the same `{i.split('/')[0] for i in ids}` set comprehension the remote-code rule uses -- so this is the two print lines and a comment saying why, not new logic. Two arms, so the number cannot drift from the models it counts: one org, four models -> says 1 uploader three orgs -> says 3 uploader(s) $ python3 tests/census_watch_test.py -> all checks passed --- tests/census_watch_test.py | 7 +++++++ tools/census_watch.py | 9 +++++++-- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/tests/census_watch_test.py b/tests/census_watch_test.py index 847529a7f..bbe02b20f 100644 --- a/tests/census_watch_test.py +++ b/tests/census_watch_test.py @@ -106,6 +106,13 @@ def text_of(models, archs=ARCHS, sig=SIG, seen=()): # 4. A reviewed not-an-alias class is still the alert, and is labeled as such. rc, res = rc_of([model("d/four", "Qwen3_5MVLAAbsorbedForCausalLM")]) check("significant class -> uncovered, exit 1", rc == 1) +# engine#2427: the count is not the demand. Four models of one class under one org is ONE mapping decision, and a +# row that says "4 model(s)" reads like four people asking. REMOTE-CODE has printed the uploader count since the +# spread rule landed; UNCOVERED now does too, so the two rows can be compared. +_rco, _rtxt = text_of([model(f"same/{i}", "OneOrgForCausalLM") for i in range(4)]) +check("one org, four models -> says 1 uploader", "from 1 uploader(s)" in _rtxt) +_rco, _rtxt = text_of([model(f"org{i}/m", "SpreadForCausalLM") for i in range(3)]) +check("three orgs -> says 3 uploader(s)", "from 3 uploader(s)" in _rtxt) check("significant class is labeled", res["significant"] == ["Qwen3_5MVLAAbsorbedForCausalLM"]) # 4b. A custom-code class (auto_map) from fewer than REMOTE_CODE_SPREAD uploaders is reported, diff --git a/tools/census_watch.py b/tools/census_watch.py index a2076b50c..45f6247b3 100644 --- a/tools/census_watch.py +++ b/tools/census_watch.py @@ -937,11 +937,16 @@ def report(models, res, previously_seen): f"alerts once {REMOTE_CODE_SPREAD} uploaders use it") elif cls in res["significant"]: print(f" !! UNCOVERED {cls} (reviewed, not an alias — docs/arch-gaps.md): " - f"{len(ids)} model(s), e.g. {ids[0]}") + f"{len(ids)} model(s) from {len({i.split('/')[0] for i in ids})} uploader(s), e.g. {ids[0]}") print(f" -> needs real engine support, not a mapping; if a backend starts " f"accepting it, record why in registry/significant.json ('mapped_ok')") else: - print(f" !! UNCOVERED {cls} (new class): {len(ids)} model(s), e.g. {ids[0]}") + # engine#2427: REMOTE-CODE already says how many uploaders a class spans, and UNCOVERED did not -- so + # four models of one class under one org read the same as four orgs standardising on it, and the first + # is one mapping decision while the second is demand. The registry grows entries nobody asked for when + # a count reads as demand. + print(f" !! UNCOVERED {cls} (new class): {len(ids)} model(s) from " + f"{len({i.split('/')[0] for i in ids})} uploader(s), e.g. {ids[0]}") # engine#1922: the registry is GENERATED from the pinned sources, so "not in the registry" cannot by itself # say whether a pin bump would fix this or whether nobody upstream has it. Say which, when it is knowable. verdict = res.get("upstream_verdict", {}).get(cls, "unknown")