test(gauntlet-timing): recognize the unlimited_vision.hydrate stage

The gauntlet perf harness parses FOCR_TIMING=1 output into named stages
so the ledger and A/B aggregator can fold seconds per pipeline stage. The
Unlimited-OCR forward now emits an "unlimited_vision.hydrate(cached)" line
on ordinary cached-tower runs and an "unlimited_vision.hydrate(batch-local)"
line on the batch spine path, accounting the one-time hydration of the
SAM/CLIP tower, projector, and widened embed tables that are cached on the
loaded model and reused across pages and batches. Before this change the
parser rejected those lines as unknown, failing any timing capture that
included them.

Add a dedicated `unlimited_vision_hydrate` pattern (ordered next to the
existing batched `vision.hydrate(batch)` info stage) that matches both the
cached and batch-local variants, and extend the synthetic mixed-precision
and batch fixtures plus the self-test so both variants are exercised and
their seconds asserted. This keeps the parser in lockstep with the runtime
instrumentation without touching any source code; the full parser self-test
stays green (95/95).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Dicklesworthstone

scripts/gauntlet_timing.py

@@ -99,6 +99,13 @@
         "vision_hydrate",
         re.compile(r"^vision\.hydrate\(batch\) (?P<s>\d+(?:\.\d+)?)s$"),
     ),
+    (
+        "unlimited_vision_hydrate",
+        re.compile(
+            r"^unlimited_vision\.hydrate\((?:cached|batch-local)\) "
+            r"(?P<s>\d+(?:\.\d+)?)s$"
+        ),
+    ),
     (
         "vision_sam_batch",
         re.compile(
@@ -1561,6 +1568,7 @@ def _cmd_aggregate_ab(args: argparse.Namespace) -> int:
 _SYNTHETIC_UNLIMITED_MIXED = """\
 [focr-timing] precision focr-mixed-ffn-int8
 [focr-timing] preprocess 0.12s
+[focr-timing]     unlimited_vision.hydrate(cached) 0.11s
 [focr-timing]   vision.sam 1.20s
 [focr-timing]   vision.clip 0.40s
 [focr-timing]   vision.bridge 0.05s
@@ -1583,6 +1591,7 @@ def _cmd_aggregate_ab(args: argparse.Namespace) -> int:
 # sam, single lines for hydrate/clip/bridge; the second sam group proves the
 # same-stage fold sums seconds and view counts).
 _SYNTHETIC_BATCH = """\
+[focr-timing]     unlimited_vision.hydrate(batch-local) 0.21s
 [focr-timing]   vision.hydrate(batch) 0.62s
 [focr-timing]   vision.sam(batch of 3, side 1024) 2.40s
 [focr-timing]   vision.sam(batch of 2, side 640) 0.80s
@@ -1615,6 +1624,10 @@ def check(name: str, ok: bool, **fields: object) -> None:
         "unlimited-mixed-precision",
         infer_precision([mixed_run]) == PRECISION_MIXED_FFN_INT8,
     )
+    check(
+        "unlimited-mixed-vision-hydrate",
+        math.isclose(mixed_run["unlimited_vision_hydrate"]["s"], 0.11),
+    )
     check(
         "unlimited-mixed-phases",
         math.isclose(mixed_run["decode_lm_head"]["s"], 1.6)
@@ -1688,6 +1701,10 @@ def check(name: str, ok: bool, **fields: object) -> None:
     # bd-t6a batched-vision lines: hydrate is its own stage; sam/clip/bridge
     # batch lines fold into the per-view stage names, summing seconds + views.
     batch = parse_run(_SYNTHETIC_BATCH)
+    check(
+        "batch-unlimited-vision-hydrate",
+        math.isclose(batch["unlimited_vision_hydrate"]["s"], 0.21),
+    )
     check("batch-hydrate", math.isclose(batch["vision_hydrate"]["s"], 0.62))
     check("batch-sam-sum", math.isclose(batch["vision_sam"]["s"], 3.20))
     check("batch-sam-views", batch["vision_sam"]["views"] == 5)