captchakraken 2.6.1 → 2.9.0

package/python/src/captchakraken/keyframes.py

@@ -1,8 +1,8 @@
 """Reduce a recorded captcha clip to the few frames the model is shown.
 
 VERBATIM PORT. Everything below the docstring is byte-identical to
-`src/video/keyframes.py` in the CaptchaKrakenFinetune repo, and
-`scripts/check_prompt_parity.py` there fails the build if the two ever diverge.
+the training-side extractor in the training repo, and
+`scripts/the parity gate` there fails the build if the two ever diverge.
 
 That is not tidiness, it is a correctness requirement. The model is trained on
 keyframes cut by that code and answers with a frame NUMBER indexing into them. If
@@ -41,7 +41,7 @@ DEFAULT_MAX_KEYFRAMES = 6
 # picture". A false "same" merges two distinct states, which loses an answer, so
 # this is the most consequential number in the file.
 #
-# MEASURED, not guessed. Over all 20 real clips in cleanSamples/test/raw, the
+# MEASURED, not guessed. Over all 20 real clips in the sample corpus, the
 # consecutive-frame differences fall into two clusters with a 64x gap:
 #
 #   same picture (compression + antialiasing)  <= 0.000067   (0.067 per mille)
@@ -162,6 +162,15 @@ class KeyframeSet:
     # `keyframes`). Empty for the other modes. Lets a caller answer "which
     # keyframe was the clip showing at source frame i?" without re-diffing.
     frame_states: List[int] = field(default_factory=list)
+    # How many distinct steady screens the clip sits on; 0 if it is not that
+    # kind of clip. INDEPENDENT OF `mode`, and the difference is the whole
+    # point: `mode` says what the slicer could PROVE about recurrence from one
+    # burst, this says what the board looks like. A three-screen captcha whose
+    # loop is longer than the recording is `even` with `steady_screens == 3`.
+    # The live driver reads this to decide whether waiting for a named screen
+    # is meaningful; reading `mode` for that put the wait off on 100% of real
+    # animated captchas. See `steady_screens()`.
+    steady_screens: int = 0
 
     def __len__(self) -> int:
         return len(self.keyframes)
@@ -226,6 +235,7 @@ class KeyframeSet:
         return {
             "stem": stem,
             "mode": self.mode,
+            "steady_screens": self.steady_screens,
             "fps": self.fps,
             "source_frames": self.source_frames,
             "params": self.params.as_dict(),
@@ -440,14 +450,22 @@ def _distinct_indices(
     return sorted(kept)
 
 
-def _detect_cycle(
+def _steady_screens(
     frames: Sequence[np.ndarray], params: KeyframeParams
-) -> Optional[Tuple[List[int], List[int]]]:
-    """`(state_medoid_indices, per_frame_state)` if the clip is a cycle of steady
-    pictures, else None.
+) -> Optional[Tuple[List[Tuple[int, int]], List[int], List[int]]]:
+    """`(holds, state_medoid_indices, state_per_hold)` if the clip is a set of
+    steady held pictures, else None.
 
-    `per_frame_state[i]` is the 0-based state of source frame i, or -1 for a
-    transition frame that belongs to no hold.
+    Split out of `_detect_cycle` because the answer is wanted TWICE and the two
+    questions are not the same one:
+
+      - "is this a cycle?" — needs a state to be seen coming BACK, which takes
+        more than one pass through the loop.
+      - "does this board sit on a few stable screens?" — needs only one pass,
+        and is what the live driver has to know in order to decide whether
+        waiting for a particular screen is meaningful.
+
+    Answering only the first left the second unasked. See `steady_screens`.
     """
     n = len(frames)
     runs = _anchor_runs(frames, params.steady_ratio)
@@ -479,6 +497,55 @@ def _detect_cycle(
     if len(state_reps) < 1:
         return None
 
+    # NO `distinct_ratio` HERE, deliberately. The merge above already separated
+    # these states by more than `steady_ratio`, which is the measured noise
+    # floor — that is the whole of "are these different pictures".
+    #
+    # `distinct_ratio` (0.02) is twenty times coarser and exists to license
+    # `cycle`'s COLLAPSE to one frame per state, where being too generous throws
+    # away the middle of a clip. Applying it here instead answers a question
+    # nobody asked and answers it wrongly: measured on a live GeeTest svg burst,
+    # the three screens are separated by 0.0056 and 0.0050 — thin line art, a
+    # few glyph strokes change — so a 0.02 bar reports a board with three
+    # obvious screens as having none. keyframes.py's own comment already said
+    # so ("real state separations top out around 0.007, well under this") and
+    # read it as evidence the check was harmless.
+    return holds, state_reps, hold_state
+
+
+def steady_screens(frames: Sequence[np.ndarray], params: KeyframeParams) -> int:
+    """How many distinct steady screens this clip sits on. 0 if it does not.
+
+    THE LIVE DRIVER'S QUESTION, and it is not `mode`. A board that advances
+    through three held pictures gives a burst that contains ONE pass, so
+    `_detect_cycle` cannot prove it recurs and the clip is sliced `even` — which
+    is right for slicing (dedup reaches the same stills) and was being read by
+    the driver as "nothing recurs, do not wait for a screen". Every real
+    geetest_v4_svg clip is exactly this shape: 2-3 holds covering 95-100% of the
+    burst, mutually distinct, and the page absolutely does come back around.
+
+    A one-way animation — the case the no-wait path exists for — is nearly all
+    transition, so it has no qualifying holds and this returns 0.
+    """
+    got = _steady_screens(frames, params)
+    return len(got[1]) if got else 0
+
+
+def _detect_cycle(
+    frames: Sequence[np.ndarray], params: KeyframeParams
+) -> Optional[Tuple[List[int], List[int]]]:
+    """`(state_medoid_indices, per_frame_state)` if the clip is a cycle of steady
+    pictures, else None.
+
+    `per_frame_state[i]` is the 0-based state of source frame i, or -1 for a
+    transition frame that belongs to no hold.
+    """
+    n = len(frames)
+    got = _steady_screens(frames, params)
+    if got is None:
+        return None
+    holds, state_reps, hold_state = got
+
     # A cycle REVISITS. More holds than states means some picture came back, which
     # is what "the video is just a shift between N steady images" describes. Equal
     # counts mean every hold was a new picture — a one-way progression (a slow
@@ -497,8 +564,10 @@ def _detect_cycle(
     if len(holds) <= len(state_reps) and len(state_reps) > 1:
         return None
 
-    # Every pair of states must be clearly different, or we are calling noise a
-    # state and would hand the model two images of the same thing.
+    # Every pair of states must be clearly different before the clip is
+    # COLLAPSED to one frame per state — that collapse is what this threshold
+    # licenses, and being too generous with it discards the middle of a clip.
+    # `steady_screens` deliberately does not apply it; see `_steady_screens`.
     for a in range(len(state_reps)):
         for b in range(a + 1, len(state_reps)):
             if frame_diff_ratio(frames[state_reps[a]], frames[state_reps[b]]) < params.distinct_ratio:
@@ -511,6 +580,96 @@ def _detect_cycle(
     return state_reps, per_frame
 
 
+def _drop_smeared(
+    frames: Sequence[np.ndarray], indices: Sequence[int], params: KeyframeParams
+) -> List[int]:
+    """Drop an index caught BETWEEN two holds, when both of them are already
+    represented in the cut.
+
+    These clips hold a picture, swap, hold the next. An evenly spaced sample can
+    land on the instant of the swap — a board part-way between two states, which
+    is a picture the puzzle never actually shows. If the model already has the
+    board before the swap AND the board after it, that frame adds nothing but a
+    smear; if either endpoint is missing, it is the only thing standing in for a
+    state and must stay.
+
+    THE MACHINERY ALREADY EXISTED AND THIS PATH NEVER ASKED IT. `_anchor_runs`
+    plus `min_hold_frames` is how `_detect_cycle` separates holds from
+    transitions (it labels the latter -1 in `frame_states`), and
+    `min_hold_frames` had exactly one reader — inside `_detect_cycle`. On the
+    `even` path the parameter was declared, serialised into every manifest, and
+    inert.
+
+    WHY THE TEST IS "BOTH NEIGHBOURING HOLDS ARE KEPT" AND NOT A PIXEL DIFF.
+    Two earlier versions were measured against both trees and both were wrong:
+
+      * *Snap to the nearest held frame* turned `[0, 16, 39]` into `[0, 16]` on
+        six eval clips, dropping a SCREEN. A page that never reaches the model is
+        unanswerable whenever the target lived on it.
+      * *Drop when some other still is within `distinct_ratio`* cut
+        an hCaptcha tile-flip animation from 6 stills to 3, because two boards of that
+        puzzle differ by ONE TILE — well inside `distinct_ratio` — so a diff
+        threshold cannot tell "the same picture again" from "the next board".
+        EXPECTED_SLICING says it directly: fewer than 6 "means dedup merged two
+        boards that differ only by the tile mid-flip, and that tile is frequently
+        the answer".
+
+    Anchoring on the HOLDS either side asks the question that actually matters —
+    does the model already see both ends of this swap — and needs no threshold of
+    its own.
+
+    A clip with no holds at all (a rotation, a continuous fade, anything in
+    permanent motion) has no transitions to speak of and is returned untouched.
+    """
+    runs = _anchor_runs(frames, params.steady_ratio)
+    holds = [(s, e) for (s, e) in runs if (e - s + 1) >= params.min_hold_frames]
+    if not holds:
+        return list(indices)               # nothing holds; nothing is a smear
+
+    # Holds showing the same picture are ONE state — the same merge
+    # `_detect_cycle` does, at the same threshold. It matters here because a
+    # cycle revisits: on a real `icon_2x2` clip the hold at 53..74 is the
+    # opening board coming back, so the still at index 0 already covers it.
+    # Counting holds instead of states kept a smear whose neighbouring picture
+    # was on screen the whole time.
+    state_of_hold: List[int] = []
+    reps: List[int] = []
+    for start, end in holds:
+        rep = _medoid(frames, list(range(start, end + 1)))
+        for k, existing in enumerate(reps):
+            if frame_diff_ratio(frames[rep], frames[existing]) <= params.steady_ratio:
+                state_of_hold.append(k)
+                break
+        else:
+            reps.append(rep)
+            state_of_hold.append(len(reps) - 1)
+
+    def hold_of(i: int) -> Optional[int]:
+        for k, (s, e) in enumerate(holds):
+            if s <= i <= e:
+                return k
+        return None
+
+    covered = {state_of_hold[h] for h in (hold_of(i) for i in indices)
+               if h is not None}
+    kept: List[int] = []
+    for i in indices:
+        if hold_of(i) is not None:
+            kept.append(i)
+            continue
+        before = max((k for k, (s, e) in enumerate(holds) if e < i), default=None)
+        after = min((k for k, (s, e) in enumerate(holds) if s > i), default=None)
+        # Only a swap BETWEEN two kept holds is redundant. A transition at the
+        # very start or end of a clip has an endpoint that was never recorded,
+        # so it is evidence of a state and stays.
+        if before is not None and after is not None \
+                and state_of_hold[before] in covered \
+                and state_of_hold[after] in covered:
+            continue
+        kept.append(i)
+    return kept
+
+
 def extract_keyframes(
     frames: Sequence[np.ndarray],
     *,
@@ -535,6 +694,7 @@ def extract_keyframes(
         reps, per_frame = cycle
         mode = "static" if len(reps) == 1 else "cycle"
         return KeyframeSet(
+            steady_screens=len(reps),
             mode=mode,
             keyframes=[
                 Keyframe(number=k + 1, source_index=idx, timestamp_ms=_ms(idx),
@@ -548,13 +708,25 @@ def extract_keyframes(
         )
 
     indices = _even_indices(n, p.max_keyframes)
+    # BEFORE dedup, so a smear does not spend budget a real state could use...
+    indices = _drop_smeared(frames, indices, p)
     if p.dedupe:
         # Applied to `even` only. `cycle` states are distinct by construction (the
         # merge in `_detect_cycle` uses this same threshold) and `static` is one
         # frame, so there is nothing to remove; and dropping a cycle keyframe here
         # would desynchronise `frame_states`, which indexes keyframes by position.
         indices = _distinct_indices(frames, indices, p)
+        # ...AND AFTER, because `_distinct_indices` BACKFILLS. Dedup frees
+        # budget and the backfill walks the clip for anything not already
+        # represented — which is exactly what a smeared frame is, so it gets
+        # picked straight back up. Measured on a 3-hold fixture: filtering only
+        # before dedup returned [0, 10, 12, 21, 25] with 10 and 21 the two
+        # smears the first pass had just removed.
+        indices = _drop_smeared(frames, indices, p)
     return KeyframeSet(
+        # Asked even though the cycle test refused: the two questions differ,
+        # and this is the one the driver needs answered.
+        steady_screens=steady_screens(frames, p),
         mode="even",
         keyframes=[
             Keyframe(number=k + 1, source_index=idx, timestamp_ms=_ms(idx),
@@ -580,7 +752,7 @@ def extract_keyframes_from_video(
 #   <media_dir>/keyframes/<stem>/keyframes.json
 #
 # Derived, regenerable, and ADDITIVE — the clip stays canonical next to it. That
-# matters most under `cleanSamples/test/`, which is irreplaceable hand-labeled
+# matters most under the held-out sample corpus, which is irreplaceable hand-labeled
 # data we never rewrite (CLAUDE.md § Data trees): extraction only ever creates a
 # new sibling directory there.
 

package/python/src/captchakraken/models.json

@@ -6,10 +6,9 @@
     "Why a map and not a constant: a model answers in whatever schema its prompt",
     "asks for. Send a version-1 model the version-2 prompt and nothing errors —",
     "it just answers worse, on every puzzle, silently. That is exactly the",
-    "2026-07-18 regression (failure-mode 3 in the finetune repo's",
-    "scripts/check_prompt_parity.py), where the shipped prompt kept asking for",
-    "the legacy output/simulate_drag/PascalCase schema long after the LoRA had",
-    "been retrained on action: drag / drags[].",
+    "2026-07-18 regression, where the shipped prompt kept asking for the legacy",
+    "output/simulate_drag/PascalCase schema long after the LoRA had been",
+    "retrained on action: drag / drags[].",
     "",
     "Hardcoding one generation makes that inevitable the moment a new model",
     "trains on different prompts: updating the constants breaks every already-",
@@ -27,10 +26,9 @@
     "never see `latest`, so they are not silently moved onto prompts they cannot",
     "produce.",
     "",
-    "Adding a model: add its entry here IN THE SAME COMMIT as publishing it. The",
-    "finetune repo's check_prompt_parity.py fails if any registered model names a",
-    "prompt_version this client ships no built-ins for, so an unmapped model",
-    "cannot reach a release.",
+    "Adding a model: add its entry here IN THE SAME COMMIT as publishing it. A",
+    "release gate fails if any registered model names a prompt_version this",
+    "client ships no built-ins for, so an unmapped model cannot reach a release.",
     "",
     "`pixel_budget` is the same idea for RESOLUTION. Qwen reads MIN_PIXELS /",
     "MAX_PIXELS from the environment and clamps each image's AREA into that band,",
@@ -47,7 +45,80 @@
     "",
     "Omit it and the client keeps its historical behaviour (floor at 448 squared,",
     "no ceiling). Absent means UNKNOWN, not zero — set it only where it has been",
-    "measured or the training run is known."
+    "measured or the training run is known.",
+    "",
+    "`availability` says whether the WEIGHTS are obtainable. Two values:",
+    "  \"public\"   — on the Hub; anyone may download and self-host it. This is",
+    "               the default when the field is absent, so every entry that",
+    "               predates the field keeps its meaning exactly.",
+    "  \"private\"  — ON THE HUB, in a PRIVATE repo. The bytes exist and",
+    "               `captchakraken fetch` pulls them; the Hub answers 401 to",
+    "               everyone whose token this account has not authorised. That",
+    "               refusal belongs to the Hub, not to us, so the client does",
+    "               NOT pre-empt it — doing so would stop our own admin token",
+    "               from fetching weights it is entitled to.",
+    "",
+    "               It is NOT a softer `licensed`, and the difference is what an",
+    "               authorised holder can do: a licensed model has nothing to",
+    "               download however good your credentials are. `latest` may",
+    "               never be private either — an unpinned self-hoster would get",
+    "               a 401 instead of a model — and the release parity gate says so.",
+    "",
+    "  \"licensed\" — NOT downloadable by anyone. Reachable only through",
+    "               api.captchakraken.com, or by a holder of a licence we issue.",
+    "               There is no Hub repo to point CAPTCHA_LORA_ADAPTER at, and",
+    "               `captchakraken fetch` refuses rather than 404ing at the Hub.",
+    "",
+    "Why it lives HERE and not only in a policy doc: this file is already the one",
+    "place that decides what an unpinned client downloads and what prompts it",
+    "sends. A second list of 'models you may not publish' kept somewhere else",
+    "would be a list that drifts, and the drift is silent in the direction that",
+    "costs the most. The publisher reads this field and REFUSES",
+    "to upload a licensed model to the Hub; the release parity gate refuses to let",
+    "`latest` be one, because an unpinned self-hoster would resolve to weights",
+    "they cannot obtain.",
+    "",
+    "`experts` is the fourth axis, and the newest. A ROUTED model is not one",
+    "adapter: Abyss is four LoRAs behind one endpoint, and the thing that picks",
+    "between them is the PROMPT FAMILY the request is about to send — grid,",
+    "pixel, video, text. See docs/MOE_LORA_DESIGN.md §11: the router is the",
+    "prompt family and it already exists, so no DOM access, no image classifier",
+    "and no cooperation from the caller is needed to reach the right expert.",
+    "",
+    "It lives here for the same reason prompt_version does. WHICH EXPERTS EXIST",
+    "IS A FACT ABOUT THE MODEL. A client that hardcoded four names would send",
+    "them to v1.2 — which serves one adapter under one name — and every request",
+    "would 404 on a model the endpoint has never heard of. ABSENT MEANS NOT",
+    "ROUTED, and that is the whole backwards-compatibility story: every model",
+    "published so far declares no `experts`, so the client sends the single",
+    "`lora_name` on every request exactly as it did before this field existed.",
+    "",
+    "An unmapped or unrecognised family degrades to the model's own",
+    "`lora_name` — the GENERALIST — never to another expert and never to an",
+    "error. The day the generation-2 `text` family reached ckgate without a",
+    "marker, refusing it cost every distorted-text solve in production for a",
+    "day; a caller prompting in their own words is the expected case for a",
+    "shipped model, not a 400.",
+    "",
+    "Each expert name must resolve — through `served_aliases` or as a repo id —",
+    "to a REGISTERED entry declaring the same `prompt_version` and the same",
+    "`pixel_budget` as the model that routes to it. The release parity gate",
+    "enforces that. It is what makes aliasing four arms onto one entry safe",
+    "rather than convenient: the four share a base, a schema and a band today",
+    "(measured, not assumed — runs 20260906-0142xx all carry prompt generation",
+    "2 and a flat 518400 band), and the day one of them trains at a different",
+    "generation or a different band the gate refuses the alias and that arm has",
+    "to graduate to an entry of its own. A divergence that resolved silently",
+    "through a shared entry would be the 2026-07-18 regression with four models",
+    "in it instead of one.",
+    "",
+    "The four arms are on the wire training as this is written (runs",
+    "20260906-0142xx) and none of them is published yet, so the `experts` map",
+    "below names weights that do not exist. That is the same deliberate",
+    "arming as `Abyss` itself — registered before it existed so the licence",
+    "gates were armed rather than retrofitted — and it costs nothing, because",
+    "an expert name only ever reaches the wire for a caller who asked for a",
+    "routed model in the first place."
   ],
   "latest": "CaptchaKraken/CaptchaKraken-Lora-v1.2",
   "models": {
@@ -61,7 +132,7 @@
         "min": 518400,
         "max": 518400
       },
-      "note": "Run 20260812-005302 (ready-to-deploy). PUBLIC on the Hub under Source-Available License v1.1, and the first published generation-2 model. TRAINED with floor 448^2 / ceiling 720^2, but MEASURED best served at a flat 720^2 — floor == ceiling, so every image arrives at exactly one size. Tier 2 overall 0.6115 -> 0.6412 across the full 1458-sample real eval and reCAPTCHA 3x3 exact 0.648 -> 0.715, against run-to-run noise of +/-0.001. Swept 2026-08-18 over 448/576/640/704/720/736/768/896/1024^2: the plateau is 704-736^2 and it falls off above 768^2, where a 400x580 portrait capture runs more than 40% past the ViT's 48x48 position grid. Note 640^2 is where that grid is exactly saturated and it scores WORSE (0.6357) — mild extrapolation plus real pixels beats staying inside the grid. Was served as `captcha-v12` while absent from this file, which resolved it to generation 1 prompts against generation-2 weights — the failure this file exists to prevent."
+      "note": "Generation 2, and the first published one. Trained over a range of input sizes but served at a flat 720^2: floor == ceiling, so every image arrives at exactly one size and the band cannot drift. The band was chosen by sweeping the serving floor and scoring each setting; the plateau is 704-736^2 and it falls off above 768^2, where a portrait capture runs well past the vision tower's position grid. Note that the vision tower's native grid is NOT the best setting — mild position-embedding extrapolation over real pixels beats staying inside the grid."
     },
     "CaptchaKraken/Twilight-v1.2-FP8": {
       "prompt_version": "2",
@@ -71,7 +142,7 @@
         "min": 518400,
         "max": 518400
       },
-      "note": "CaptchaKraken-Lora-v1.2 merged into Qwen/Qwen3.5-9B at FP8-dynamic. The weights the hosted API answers with. Generation 2, same band as the adapter it is made from: a merge that resolved to a different prompt generation or a different pixel budget than its own LoRA would be the 2026-07-18 regression with extra steps."
+      "note": "CaptchaKraken-Lora-v1.2 merged into Qwen/Qwen3.5-9B at FP8-dynamic. Generation 2, same pixel band as the adapter it is made from — a merge that resolved to a different prompt generation or a different band than its own LoRA is exactly the mispairing this file exists to prevent."
     },
     "CaptchaKraken/Sunlight-v1.2-AWQ-4bit": {
       "prompt_version": "2",
@@ -89,7 +160,7 @@
       "base_model": "RedHatAI/Qwen3.5-9B-FP8-dynamic",
       "lora_revision": "main",
       "lora_name": "captcha",
-      "note": "Currently served in production. PRIVATE on the Hub, so prompts.json can never be fetched for it — this entry is the only thing that maps it to a prompt generation."
+      "note": "Generation 1. Private on the Hub, so prompts.json cannot be fetched for it — this entry is the only thing that maps it to a prompt generation."
     },
     "CaptchaKraken/CaptchaKrakenV1_Lora": {
       "prompt_version": "1",
@@ -97,24 +168,115 @@
       "base_model": "RedHatAI/Qwen3.5-9B-FP8-dynamic",
       "lora_revision": "main",
       "lora_name": "captcha",
-      "note": "Published before prompts.json existed — no such file in the repo, so it resolves from here."
+      "note": "Generation-1 LoRA on Qwen3.5-9B. Superseded by v1.2; kept registered so an existing pin keeps resolving to the prompts it was trained on."
     },
     "CaptchaKraken/Sunlight-AWQ-4bit": {
       "prompt_version": "1",
       "kind": "merged",
       "lora_name": "captcha",
-      "note": "Ships its own prompts.json; this entry keeps it resolvable offline."
+      "note": "Generation 1 merged into the base model at AWQ 4-bit."
     },
     "CaptchaKraken/Twilight-FP8": {
       "prompt_version": "1",
       "kind": "merged",
       "lora_name": "captcha",
-      "note": "Ships its own prompts.json; this entry keeps it resolvable offline."
+      "note": "Generation 1 merged into the base model at FP8-dynamic."
+    },
+    "CaptchaKraken/Abyss": {
+      "availability": "licensed",
+      "prompt_version": "2",
+      "kind": "lora",
+      "base_model": "Qwen/Qwen3.5-9B",
+      "lora_name": "abyss-general",
+      "pixel_budget": {
+        "min": 518400,
+        "max": 518400
+      },
+      "experts": {
+        "grid": "abyss-grid",
+        "pixel": "abyss-general",
+        "video": "abyss-video",
+        "text": "abyss-text"
+      },
+      "note": "A routed mixture of four expert LoRAs on Qwen3.5-9B — grid, pixel, video and text — selected by prompt family. Hosted only: `availability` refuses the weights, and being nameable is not being downloadable. A licence holder does name this model, which is why it and each of its arms has a served_aliases entry. `lora_name` is `abyss-general` rather than a fifth name because the generalist IS the fallback for any family `experts` does not map, so the two point at one adapter and the mixture needs one fewer resident LoRA slot."
+    },
+    "CaptchaKraken/Abyss-27B": {
+      "availability": "private",
+      "prompt_version": "2",
+      "kind": "lora",
+      "base_model": "Qwen/Qwen3.8-27B",
+      "lora_revision": "main",
+      "lora_name": "abyss-27b",
+      "pixel_budget": {
+        "min": 518400,
+        "max": 518400
+      },
+      "note": "A single-adapter Qwen3.8-27B. NOT the routed Abyss and not one of its arms — the base model is what a self-hoster loads, so it could never share that entry. Archived rather than served."
+    },
+    "CaptchaKraken/Abyss-grid": {
+      "availability": "private",
+      "prompt_version": "2",
+      "kind": "lora",
+      "base_model": "Qwen/Qwen3.5-9B",
+      "lora_revision": "main",
+      "lora_name": "abyss-grid",
+      "pixel_budget": {
+        "min": 518400,
+        "max": 518400
+      },
+      "note": "The 'grid' expert arm of the routed CaptchaKraken/Abyss. It has its own entry rather than an alias onto the router because it has its own weights at its own repo id, and `experts` names what goes on the wire. It declares the router's prompt generation and pixel band, which is what the parity gate requires of every arm and what makes the mixture coherent."
+    },
+    "CaptchaKraken/Abyss-text": {
+      "availability": "private",
+      "prompt_version": "2",
+      "kind": "lora",
+      "base_model": "Qwen/Qwen3.5-9B",
+      "lora_revision": "main",
+      "lora_name": "abyss-text",
+      "pixel_budget": {
+        "min": 518400,
+        "max": 518400
+      },
+      "note": "The 'text' expert arm of the routed CaptchaKraken/Abyss. Own entry, own weights, and it declares the router's prompt generation and pixel band — see CaptchaKraken/Abyss-grid."
+    },
+    "CaptchaKraken/Abyss-video": {
+      "availability": "private",
+      "prompt_version": "2",
+      "kind": "lora",
+      "base_model": "Qwen/Qwen3.5-9B",
+      "lora_revision": "main",
+      "lora_name": "abyss-video",
+      "pixel_budget": {
+        "min": 518400,
+        "max": 518400
+      },
+      "note": "The 'video' expert arm of the routed CaptchaKraken/Abyss. Own entry, own weights, and it declares the router's prompt generation and pixel band — see CaptchaKraken/Abyss-grid."
+    },
+    "CaptchaKraken/Abyss-general": {
+      "availability": "private",
+      "prompt_version": "2",
+      "kind": "lora",
+      "base_model": "Qwen/Qwen3.5-9B",
+      "lora_revision": "main",
+      "lora_name": "abyss-general",
+      "pixel_budget": {
+        "min": 518400,
+        "max": 518400
+      },
+      "note": "The 'pixel' expert arm of the routed CaptchaKraken/Abyss and its generalist fallback: the router's own `lora_name` names this entry. Own entry, own weights, and it declares the router's prompt generation and pixel band — see CaptchaKraken/Abyss-grid."
     }
   },
   "served_aliases": {
-    "_comment": "A hosted endpoint serves a bare name, not a repo id. Map it back so prompt resolution works for callers who only ever see the alias.",
-    "captcha": "CaptchaKraken/CaptchaKraken_v1.1",
-    "captcha-v12": "CaptchaKraken/CaptchaKraken-Lora-v1.2"
+    "_comment": "A hosted endpoint serves a bare name, not a repo id. Map it back so prompt resolution works for callers who only ever see the alias. The hosted API serves one model behind the permanent public name `captcha`, whatever the caller sends, so `captcha` means whichever adapter is current there. Self-hosters resolve by repo id via CAPTCHA_LORA_ADAPTER and are unaffected. Move this in the same change as the gateway's upstream model, or the hosted model answers a prompt generation it was not trained on.",
+    "captcha": "CaptchaKraken/CaptchaKraken-Lora-v1.2",
+    "captcha-v12": "CaptchaKraken/CaptchaKraken-Lora-v1.2",
+    "_comment_abyss": "An alias says which model a served NAME means; `availability` says whether its weights can be downloaded. The two are independent. A licence holder names this model — the hosted API accepts it from a licensed key and lists it on /v1/models — and without this line prompt resolution falls through to the `latest` fallback, which is the model/generation mispairing this file exists to prevent. It does not make the weights fetchable.",
+    "abyss": "CaptchaKraken/Abyss",
+    "_comment_abyss_experts": "The four expert arms. These are the names that go on the wire — a routed request for a grid names `abyss-grid`, never `abyss` — so without these lines prompt resolution falls through to `latest` on every routed solve. Aliasing the arms onto one entry is deliberate and checked: they share a base, a prompt generation and a pixel band, and the parity gate requires every expert name to resolve to a registered entry declaring the SAME prompt_version and pixel_budget as the router — so the day an arm trains at another generation or band, the gate refuses the alias and that arm has to graduate to an entry of its own.",
+    "abyss-grid": "CaptchaKraken/Abyss-grid",
+    "abyss-general": "CaptchaKraken/Abyss-general",
+    "abyss-video": "CaptchaKraken/Abyss-video",
+    "abyss-text": "CaptchaKraken/Abyss-text",
+    "abyss-27b": "CaptchaKraken/Abyss-27B"
   }
 }