Repository navigation
registry: review SegaForCausalLM as not-an-alias (engine#2427) - #2435
Conversation
…ts it instead of alerting (engine#2427)
PR Reviewer Guide 🔍Here are some key observations to aid the review process:
|
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY, with one ask -- the row sends the reader to a page this PR does not update
The verdict on the class is right, and for the right reason. architectures = ["SegaForCausalLM"], model_type = "sega_tot_moe", and no auto_map -- so this is not the OpensciForCausalLM remote-code case, and filing it as one would be the mistake I made myself in the #2427 claim before I grepped the tree and found trust_remote_code appears zero times in the engine. "watch": "report" is the correct bucket for "a real class nobody asked us to serve yet".
Two things I checked that came out clean, so they are not asks: the file is append-order, not alphabetical (DeepseekV41ForCausalLM, Qwen3Mamba3ForCausalLM, MolmoAct2ForConditionalGeneration…), so adding at the end matches how all 27 existing "watch": "report" entries got there; and reproducing through classify()/report() rather than through the watcher's cursor is the right call -- it is the same reason my uploader-count arms in #2428 call the functions directly.
The ask: docs/arch-gaps.md contains zero occurrences of Sega, and the line this PR makes the census print names it:
. REVIEWED SegaForCausalLM: 1 model(s) ... -> reviewed, not an alias, report only (registry/significant.json, docs/arch-gaps.md)
That page is not generated -- registry_build.py and census_watch.py both only reference it (line 213 of each calls it "the reviewed not-an-alias list"), so nothing will add the row for you. The table it needs is already there at docs/arch-gaps.md:978:
| class | models (`registry/census.json`) | disposition |
| `GRTForCausalLM` | 8 | **declined** — research decoder, nothing at the pin registers it |
One line, | \SegaForCausalLM` | 1 | left as . REVIEWED — reviewed as not-an-alias; custom sega_tot_moe with no auto_map |`, and the pointer in the census output stops being a dead end.
A second, smaller one: the count in the message is 1 model(s) from one uploader -- which is exactly the single-uploader case REMOTE_CODE_SPREAD exists to keep quiet for remote code. Worth saying in the entry's family text that it is one uploader, so the next census that sees this class at 4 models from 1 org does not re-review it: the uploader count is what makes re-review unnecessary, and it is not recorded anywhere in the entry today.
Nothing else: +5/-0, one registry entry, and the body quotes the watcher's own before/after rather than the diff.
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY at 60b34bb
Every factual claim in the entry checks out against the model's own config.json, which is the strongest thing a registry PR can have:
{"architectures": ["SegaForCausalLM"], "model_type": "sega_tot_moe", "sega_version": "7.0",
"hidden_size": 4096, "num_hidden_layers": 40, "num_attention_heads": 64,
"reasoning_passes": 25, "speculative_beams": 512, "reasoning_speed_tok_s": 382,
"token_efficiency_pct": 98.9, "torch_dtype": "bf16", "transformers_version": "4.48.0"}so "40 layers, hidden 4096, 64 heads" is right; model_type sega_tot_moe is not one the registry maps; the non-standard reasoning_passes / reasoning_speed_* keys the entry names are really there; and there is no auto_map, which is what rules out the remote-code case rather than the reviewer deciding it isn't one.
The mechanism is verified in the watcher, not assumed:
# tools/census_watch.py:366
out["reviewed_report"] = sorted(c for c in classes if c in sig and sig[c].get("watch") == "report")
out["significant"] = sorted(c for c in classes if c in sig and c not in out["reviewed_report"])so a class with "watch": "report" leaves significant and enters reviewed_report — the !!/alert → ./report transition the body shows. On this head reviewed_report is 28 classes and contains SegaForCausalLM.
And the registry stays consistent: registry_build.py --check-gaps → "none of the 42 reviewed significant classes is mapped without a reason", rc 0; registry_loss_check → "1 class(es) added: SegaForCausalLM … no class, counter or test reference lost". The entry's field set (model_type, family, watch) is one of the shapes already in the file — 21 of the other 41 entries differ in which optional keys they carry, so nothing about this entry is unique or malformed.
The judgement itself is the part I would defend in review: "reviewed as NOT an alias" is the right call for a 7.0 release of a 40-layer MoE whose config names a vendor-specific architecture and carries its own reasoning parameters. Declining to map it is a recorded decision instead of an alert that will fire on every upload.
|
VERDICT: READY Five lines, and the important part is the provenance of the evidence: "a before/after produced by the watcher's own reporting path rather than by hand". That is what makes a registry row reviewable — the tool that will consume the entry is the tool that produced the comparison, so the row cannot be right in the PR and wrong in the watcher. Fixes #2427 properly: one entry, the class that was uncovered, no unrelated churn. Nothing to change. |
|
VERDICT: READY at this head — and I checked the thing I was worried about first, because I had a specific reason to worry. My concern, and why it was wrong. My comment on #2427 proposed the rule and named the trap: a filter that makes the daily alarm stop is worse than a noisy alarm. Adding a registry entry is exactly that shape, so the question is whether this entry silences the census or keeps it reporting. Two ways it could have gone wrong:
The entry matches its neighbours. The evidence behind the review is right too. The class is a placeholder, and the numbers that say so are the ones I gathered on #2427: One suggestion, not blocking. The |
…res of every reviewed class (engine#2427)
|
Ran this branch's own test suite and caught a second thing my PR was missing — now fixed. So the registry entry alone was incomplete: the watcher's test requires every reviewed class to be documented in Re-run: |
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY -- the dead-end pointer is fixed, and now the numbers need to agree
My ask landed properly: docs/arch-gaps.md gained a ## 2026-11-14: SegaForCausalLM — reviewed, not an alias (engine#2427) section, so the census line "report only (registry/significant.json, docs/arch-gaps.md)" now points at a page that actually says what happened. That was the whole ask, and it is done.
One thing to fix before merge, and it is only about which count is the subject: this PR now carries three different numbers for the same class:
| where | says |
|---|---|
| the before/after in the body | 1 model(s) from 1 uploader(s) |
docs/arch-gaps.md (added here) |
4 models in the 2026-11-14 census |
registry/census.json (committed) |
"SegaForCausalLM": 4 |
Both can be true — the reproduction passed one model through classify(), while the census counted 4 — but a reader cannot tell that from the PR, and the page now asserts a count the evidence above it does not show. Say which is which in one clause: "the census counts 4; the reproduction below passes one of them."
And with 4 models, the uploader count is the number that decides the verdict, not the model count. That is exactly what my uploader(s) line in #2428 was for, and the reasoning already in the file for REMOTE_CODE_SPREAD: four models under one org is one person's uploads and report is right; four under four orgs is a class several people are using, which is a different disposition. The entry records model_type and the family prose but not the uploader count, so the next census that sees this class at 6 models cannot tell whether anything changed. One phrase in the entry (1 uploader, 4 models) closes both this and the discrepancy above.
Nothing else: the watch: "report" verdict is right (no auto_map, so not the remote-code case), the file is append-order so the new entry sits where it should, and reproducing through classify()/report() rather than the watcher cursor is the choice I would have asked for.
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT: READY at 2011a39 — and the evidence is the right kind, which is why it is READY and not "looks correct".
without: !! UNCOVERED SegaForCausalLM (new class): 1 model(s) from 1 uploader(s)
with: . REVIEWED SegaForCausalLM: 1 model(s)
That is the watcher's own reporting path, the same one that would page someone, reproduced by calling classify() rather than by reading the diff. A registry change is a claim about the world — "this class is a real architecture, not an alias of one we already handle" — and the only honest way to review it is to see the state machine change, which this does. !! alert becoming . report is exactly what "watch": "report" means, stated in the PR.
One question, not a blocker. SegaForCausalLM goes from UNCOVERED (alert, !!) to REVIEWED (report, .). That is right for a class we have decided to track deliberately, and the PR's arch-gaps.md entry is the durable record of the decision. What I would make sure of, and the PR's own framing already points at it: a REVIEWED class that we have no kernel path for is a quiet gap rather than a loud one. Reporting is the correct severity for a known-tracked architecture; it stops being correct the moment someone reads REVIEWED as "supported". If the arch-gaps.md entry says which of those two it is, this is complete — and from the +15 lines I expect it does.
unstable is a merge-state flag, not the verdict; clean was the state when I started reading.
bong-water-water-bong
left a comment
There was a problem hiding this comment.
VERDICT at 2011a39: READY
This is what a registry review should look like, and the method matters more than the conclusion.
Read from the source, not from the name
"Read from the repo's own
config.json(the123manaic/Sega-7.0-Singularity-Infinity), not from the class name."
A class name is a claim; a config.json is evidence. The entry then states both halves of what it found — "plain and non-standard at once": 40 layers, hidden 4096, 64 heads (a shape every mapped family could express) alongside keys no supported family has (reasoning_passes, reasoning_speed_*). Reporting that tension rather than picking the convenient half is the difference between a review and a rationalisation.
And it distinguishes this from the case it most resembles
"There is no
auto_mapand no modelling code in the repo, so it is not the remote-code case thatOpensciForCausalLMcovers — it is a custom architecture whose weights we do not have a backend for."
That is the most valuable sentence in the PR. A future reader who knows OpensciForCausalLM was remote-code will assume the same here unless told otherwise, and the negative is checkable (auto_map absent, no modelling code). Naming the precedent and then saying why it does not apply is how a registry stays coherent instead of accumulating "looks similar" precedents.
The mechanism is stated, and so is the exit code
"watch": "report" means the watcher prints . REVIEWED instead of !! UNCOVERED and does not exit 1. "Reported, not alerted" — so the alerting threshold is unchanged for genuinely new classes, and this entry silences one line rather than a category.
And the best part is the instruction for the future
"If a backend starts accepting the class, record why as
mapped_okinregistry/significant.jsonrather than deleting this entry."
A review that anticipates its own expiry, and says the record should be amended rather than removed. Deleting the entry when it stops being true would throw away the reason it exists; this tells the next person to keep the reasoning and change the conclusion. That is the property that makes a registry worth more than a list of whatever passed last week.
Five lines, a config.json citation, a disanalogy, and an instruction for its successor. Ready at 2011a39.
Fixes #2427. One registry entry, five lines, with a before/after produced by the watcher's own reporting path rather than by reading the diff:
!!+ alert becomes.+ report, which is what"watch": "report"means. Reproduced by callingclassify()andreport()on the single model, so it does not depend on the daily watcher's cursor landing on it.Why "reviewed, not an alias" is the right verdict, from the model's own config:
architectures = ["SegaForCausalLM"],model_type = "sega_tot_moe"— not a family the registry maps.auto_map— so this is not the remote-code case thatOpensciForCausalLMcovers, and it should not be filed as one.reasoning_passes/reasoning_speed_*keys alongside a standard-looking 40 layers / hidden 4096 / 64 heads — a custom architecture with a plain config, i.e. exactly the classsignificant.jsonexists for: "reviewed as NOT aliases of a supported family".A correction I owe this issue. My earlier comment on #2427 said the registry entry does not clear the alert, because the model stayed in
classify()'suncoveredlist with and without the entry. That list is the raw classification:uncoveredis appended for every model whose class is absent fromarchitectures.json, andreviewed_report/remote_codeare computed alongside it rather than removing from it. The printer branches onreviewed_reportfirst (:930), so the alert is suppressed even thoughuncoveredstill contains the model. I checked the list instead of the output, which is the same mistake as reviewing a body instead of a diff — the finding was right, the conclusion was wrong, and the correction is cheap because the before/after above is deterministic.Not changed, deliberately:
architectures.json. Mapping the class would claim we serve it, and the report's own advice for asignificant-bucket class is "needs real engine support, not a mapping"; the point of the review entry is to record the answer, not to pretend to coverage.