captchakraken 2.6.0 → 2.8.0

package/python/src/captchakraken/page_solver.py

@@ -53,7 +53,7 @@ from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
 from .action_types import CaptchaAction
 from .solver import CaptchaSolver, UnsupportedCaptchaError
 from .timing import PhaseBudget, timings_enabled
-from .trajectory import generate_trajectory
+from .humanize import Humanizer, resolve as resolve_humanizer
 
 DEBUG = os.getenv("CAPTCHA_DEBUG", "0") == "1"
 
@@ -163,6 +163,14 @@ class SolveResult:
     is_solved: bool
     final_mouse_position: Tuple[float, float]
     token_usage: List[Dict[str, Any]] = field(default_factory=list)
+    #: Where this solve's wall-clock went, in milliseconds per phase — the same
+    #: partition `CAPTCHA_TIMINGS=1` prints, handed to the caller instead of to
+    #: stderr. `{}` when the result was built outside a solve.
+    #:
+    #: Returned rather than only logged because "the solve took 12s" is not
+    #: actionable and "the settle monitor spent 4s of it" is, and a caller
+    #: measuring a fleet cannot scrape stderr from inside its own process.
+    phases: Dict[str, float] = field(default_factory=dict)
 
 
 @dataclass
@@ -209,6 +217,48 @@ class PageSolverConfig:
     value tuned on one driver can be found on the other.
     """
 
+    # ── how the driver moves ───────────────────────────────────────────────
+    #: "mouse" (default), "mobile" or "none". See `humanize.py`.
+    #:
+    #: Not a realism dial — a choice of INPUT DEVICE. "mobile" dispatches touch
+    #: events with finger kinematics, and on a touch-only widget that is the
+    #: difference between the page's handlers firing and not. "none" is the
+    #: shortest legal path to the same DOM effect, for fixtures and for callers
+    #: who humanise somewhere else in their stack.
+    #:
+    #: None means unset: `CAPTCHA_HUMANIZATION`, else "mouse".
+    humanization: Optional[str] = None
+    #: Your own `humanize.Humanizer`. Overrides `humanization` entirely — the
+    #: driver then makes no decisions about pointer motion at all.
+    humanizer: Optional[Humanizer] = None
+    #: mobile only. The thing that is actually TOUCHED, when it is not the page
+    #: object — an Appium/Selenium WebDriver on a real handset. Left None, the
+    #: mode dispatches CDP touch events at the page it was given.
+    touch_driver: Optional[Any] = None
+    #: mobile only. CSS-pixel -> device-pixel transform for `touch_driver`,
+    #: e.g. `{"scale": 3.0, "origin": (0, 132)}`. See AppiumTouchBackend; the
+    #: default identity is right for browser emulation.
+    touch_transform: Optional[Dict[str, Any]] = None
+    #: Where the pointer starts. Setting it stops the first gesture of a solve
+    #: crossing the whole window from the origin.
+    starting_mouse_position: Optional[Tuple[float, float]] = None
+
+    # ── which model answers ────────────────────────────────────────────────
+    #: Force ONE expert of a routed model — "pixel", "grid", "video" or "text".
+    #:
+    #: A routed model (Abyss) is four adapters behind one endpoint, and the
+    #: router is the prompt family the request is about to send, so the default
+    #: (None) already reaches the right one with no help from the caller. This
+    #: is the override: serve one arm, drive only the puzzles it owns, which is
+    #: what a per-arm benchmark needs and what a licence holder pinning a single
+    #: expert wants.
+    #:
+    #: Refused at construction against a model that serves one adapter — every
+    #: model published so far — because a run that quietly measured the
+    #: generalist and reported it as the expert is a number nobody can catch.
+    #: None means unset: `CAPTCHA_EXPERT`, else route by family.
+    expert: Optional[str] = None
+
     # 45s, and the loop count that fits inside it rather than one that needs
     # policing by the clock. A round costs ~4-7s once the waits below are paid,
     # so six rounds is the budget; ten never fitted and only ever expressed
@@ -317,6 +367,38 @@ class PageSolverConfig:
     # still a better use of the remaining budget than a timeout.
     keyframe_wait_timeout_ms: int = 6_000
     keyframe_wait_poll_ms: int = 120
+    #: Extra wall clock granted ONCE, the first time a solve escalates to a
+    #: recording. NOT a looser `overall_solve_timeout_ms`.
+    #:
+    #: That budget is sized for ROUNDS — "a round costs ~4-7s, so six is the
+    #: budget". The recording path is not a round. It is a fixed extra stage
+    #: costing the burst, the slice, one MULTI-IMAGE inference (six keyframes,
+    #: several times a still's) and the wait for the widget to come back round
+    #: to the frame the model chose. Nothing in the 45s was ever set aside for
+    #: it, so an escalation started at ~35s ran the clock out mid-burst and
+    #: reported a TIMEOUT — which reads as a slow model rather than as a budget
+    #: with no room for the thing the solver had just decided to do.
+    #:
+    #: Measured 2026-08-22, Tier 3 run 32596340560: EVERY python-port failure on
+    #: hcaptcha_fish_swim_different, hcaptcha_number_with_highest_value_video and
+    #: hcaptcha_tile_flip_video was "exceeded overall_solve_timeout_ms during
+    #: recording the animated challenge", at 45.7-52.7s elapsed. The same three
+    #: fixtures solve in 11-20s on the rounds where the still path happens to
+    #: answer them, so it is the escalation that does not fit, not the puzzle.
+    #:
+    #: Granted only when `video_solve_enabled` — a caller who wants a hard
+    #: deadline turns recording off, which is the switch that already means
+    #: "fail fast rather than spend the recording time".
+    video_extra_inference_ms: int = 8_000
+
+    def video_budget_ms(self) -> int:
+        """What one escalation to recording is allowed to cost, on top.
+
+        DERIVED, so a longer burst or a longer keyframe wait carries its own
+        budget instead of quietly reintroducing the timeout this exists to fix.
+        """
+        return (self.video_burst_duration_ms + self.keyframe_wait_timeout_ms
+                + self.video_extra_inference_ms)
 
     # Grid load / dynamic-refresh timing.
     # How long to wait for hCaptcha's task images to paint before screenshotting
@@ -356,16 +438,93 @@ class PageSolverConfig:
 # solver.ts — keep both in the same order with the same selectors.
 VENDOR_WIDGET_LOCATORS = [
     {"puzzle_source": "geetest", "selectors": [".geetest_box", ".geetest_panel_box", ".geetest_popup_window", ".geetest_widget"]},
-    {"puzzle_source": "tencent", "selectors": ['iframe#tcaptcha_iframe_dy', 'iframe[id*="tcaptcha"]', 'iframe[src*="captcha.gtimg.com"]', 'iframe[src*="captcha.qq.com"]']},
+    # Tencent renders IN THE HOST DOCUMENT since 2026-08-11; before that it was
+    # `iframe#tcaptcha_iframe_dy`. Both shapes are listed, in-page first,
+    # because the iframe build is still deployed on sites pinning an older
+    # widget and costs nothing to keep. Dropping the in-page selectors is what
+    # made the client blind to every live Tencent captcha for twelve days.
+    #
+    # `iframe[id^="tcaptcha"]`, NOT `[id*=...]`. The substring form also matched
+    # MTCaptcha's `mtcaptcha-iframe-1` — "mtcaptcha" contains "tcaptcha" — so
+    # Tencent's entry was silently the only thing detecting MTCaptcha at all,
+    # which is why `.mtcap` matching nothing went unnoticed. Anchored, it still
+    # matches the real `tcaptcha_iframe_dy` and claims nobody else's widget.
+    {"puzzle_source": "tencent", "selectors": ['#tcaptcha_transform_dy', '#tCaptchaDyContent', '.tencent-captcha-dy__content', 'iframe#tcaptcha_iframe_dy', 'iframe[id^="tcaptcha"]', 'iframe[src*="captcha.gtimg.com"]', 'iframe[src*="captcha.qq.com"]']},
     {"puzzle_source": "yidun", "selectors": [".yidun_panel", ".yidun"]},
-    {"puzzle_source": "yandex", "selectors": [".CheckboxCaptcha"]},
+    # Yandex SmartCaptcha is IFRAMED, and `.CheckboxCaptcha` is a class inside
+    # that frame's document — `query_selector` does not cross a frame boundary,
+    # so the host page never carried it and this entry matched nothing, ever.
+    # Challenge frame first, anchor second, exactly like reCAPTCHA above.
+    # `.CheckboxCaptcha` stays for an inline embed that renders it directly.
+    {"puzzle_source": "yandex", "selectors": ['iframe[src*="smartcaptcha.yandexcloud.net/advanced"]', 'iframe[src*="smartcaptcha.yandexcloud.net"]', ".CheckboxCaptcha"]},
     {"puzzle_source": "lemin", "selectors": ["#lemin-cropped-captcha", ".lemin-captcha-popup"]},
     {"puzzle_source": "prosopo", "selectors": [".prosopo-modalInner", ".procaptcha-checkbox"]},
-    {"puzzle_source": "mtcaptcha", "selectors": [".mtcap"]},
+    # MTCaptcha is IFRAMED too: `<div class="mtcaptcha"><iframe
+    # id="mtcaptcha-iframe-1" src="https://service.mtcaptcha.com/...">`. `.mtcap`
+    # is the class prefix used INSIDE that frame (`mtcap-inputtext`), and a CSS
+    # class selector matches whole tokens, so it never matched the host page's
+    # `class="mtcaptcha"` either. Kept last for an inline embed.
+    {"puzzle_source": "mtcaptcha", "selectors": ['iframe[src*="service.mtcaptcha.com"]', 'iframe[id^="mtcaptcha-iframe"]', ".mtcaptcha", ".mtcap"]},
     {"puzzle_source": "botdetect", "selectors": [".BDC_CaptchaDiv"]},
 ]
 
 
+# ── which vendor's code the page LOADED, as opposed to what it rendered ─────
+#
+# A selector is a claim about markup, and markup is the half of a captcha the
+# vendor is free to rewrite overnight — it is an anti-bot surface, so churn is
+# the point. The REQUEST is far more stable: Tencent moved its widget out of an
+# iframe and renamed every class on 2026-08-11, and went on fetching from
+# `turing.captcha.gtimg.com` and `turing.captcha.qcloud.com` throughout. The
+# substring `captcha.gtimg.com` — already in the table above, on a selector that
+# stopped matching — never left the wire.
+#
+# This is a TRIPWIRE, not a detection path. A URL says which vendor is on the
+# page; it cannot say where the widget is, and the solver needs an ELEMENT to
+# screenshot, to scope its controls against, and to drag. What it buys is the
+# difference between the two things a null detection can mean:
+#
+#   · no captcha here (reCAPTCHA v3 / invisible / not triggered yet) — fine, and
+#     what the message used to guess unconditionally;
+#   · the vendor's code is loaded and running and NOTHING WE LOOK FOR MATCHES —
+#     i.e. the DOM moved under us. That is a bug report, and it took twelve days
+#     to notice the last time because the client said the first thing while
+#     meaning the second.
+#
+# Hosts measured 2026-08-24 by loading each vendor's demo page and recording
+# every third-party request (see scripts/check_vendor_selectors.py --hosts).
+#: The two vendors with bespoke handling in this file. EVERYTHING else shares the
+#: generic path, and the two behaviours below are gated on "not one of these" —
+#: spelled as this set rather than as `== "unknown"`, which is what they used to
+#: say. The two were identical only while `unknown` was the sole third value, so
+#: the day anyone reports a vendor by name — to constrain which grid shapes it may
+#: be solved as, say — `== "unknown"` silently turns OFF typed-challenge detection
+#: for MTCaptcha, Yandex and BotDetect (all three ARE typed captchas) and the
+#: animated settle probe for GeeTest and Tencent. Neither failure raises; the text
+#: captcha just becomes unsolvable and the animated board gets answered from one
+#: arbitrary frame.
+VENDORS_WITH_BESPOKE_HANDLING = frozenset({"hcaptcha", "recaptcha"})
+
+VENDOR_URL_MARKERS = [
+    {"puzzle_source": "hcaptcha", "hosts": ["hcaptcha.com"]},
+    {"puzzle_source": "recaptcha", "hosts": ["google.com/recaptcha", "recaptcha.net"]},
+    {"puzzle_source": "turnstile", "hosts": ["challenges.cloudflare.com"]},
+    {"puzzle_source": "geetest", "hosts": ["geetest.com"]},
+    {"puzzle_source": "tencent", "hosts": ["captcha.gtimg.com", "captcha.qcloud.com"]},
+    {"puzzle_source": "yidun", "hosts": ["dun.163.com", "cstaticdun.126.net",
+                                         "necaptcha.nosdn.127.net"]},
+    {"puzzle_source": "yandex", "hosts": ["smartcaptcha.yandexcloud.net"]},
+    {"puzzle_source": "lemin", "hosts": ["leminnow.com"]},
+    {"puzzle_source": "prosopo", "hosts": ["prosopo.io"]},
+    {"puzzle_source": "mtcaptcha", "hosts": ["mtcaptcha.com"]},
+    # BotDetect is deliberately absent and must stay absent. It is a SELF-HOSTED
+    # library — the image comes from the application's own origin
+    # (`BotDetectCaptcha.ashx`), so there is no vendor host to see and a URL
+    # tripwire cannot cover it. Recording that is the point: an empty result for
+    # a BotDetect page means "this check does not apply", not "no captcha".
+]
+
+
 # ── where the answer goes, when it is not a click ───────────────────────────
 #
 # Both tables are ordered VENDOR-FIRST, GENERIC-LAST, and the driver takes the
@@ -382,7 +541,13 @@ VENDOR_WIDGET_LOCATORS = [
 
 # A distorted-text captcha's answer box. The three vendor entries are the three
 # types in instructions.py::TEXT_TYPES.
-TEXT_INPUT_SELECTORS = [
+#
+# Split in two because the two halves are safe in different places. The NAMED
+# half identifies a captcha's answer box wherever it sits; the GENERIC half only
+# means "the text box in this widget" and is trustworthy only when the scope
+# already is the widget. `_answer_box` widens past the widget for BotDetect and
+# may take the named half with it, never the generic one.
+TEXT_INPUT_VENDOR_SELECTORS = [
     # BotDetect — the input is application-defined, so match the id fragment its
     # own docs and samples use. These three are what the nightly collector
     # already drives (src/captchaCollection/sources.py).
@@ -397,6 +562,9 @@ TEXT_INPUT_SELECTORS = [
     ".AdvancedCaptcha-Input input",
     "input.Textinput-Control",
     'input[name="rep"]',
+]
+
+TEXT_INPUT_GENERIC_SELECTORS = [
     # Generic — an input the page itself labels as the captcha answer.
     'input[name*="captcha" i]',
     'input[id*="captcha" i]',
@@ -411,6 +579,8 @@ TEXT_INPUT_SELECTORS = [
     "textarea",
 ]
 
+TEXT_INPUT_SELECTORS = TEXT_INPUT_VENDOR_SELECTORS + TEXT_INPUT_GENERIC_SELECTORS
+
 # The handle you drag on a puzzle-piece slider. NOT the piece: on every one of
 # these vendors the piece is inert decoration that the handle carries, so a
 # drag starting on the piece moves nothing at all.
@@ -419,7 +589,10 @@ SLIDER_HANDLE_SELECTORS = [
     ".geetest_slider_button",
     ".geetest_btn",
     ".geetest_slider .geetest_arrow",
-    # Tencent
+    # Tencent. The post-2026-08-11 knob is a bare div — no id, no role=slider,
+    # no aria-valuenow — so every generic fallback below misses it and it has to
+    # be named. The three after it are the pre-redesign widget.
+    ".tencent-captcha-dy__slider-block",
     "#tcaptcha_drag_thumb",
     ".tc-slider-normal",
     "[id*=slideBlock]",
@@ -476,23 +649,33 @@ class PageSolver:
         self.config = config or PageSolverConfig()
         # One CaptchaSolver for the whole driver: it owns the planner, which
         # accumulates token usage and holds the HTTP session to vLLM.
+        #
+        # `expert` reaches the solver from the config, so the knob is in the
+        # same object as every other tunable and matches the TS port's
+        # `CaptchaKrakenConfig.expert`. An explicit kwarg still wins — a caller
+        # who built the argument list themselves has said the more specific
+        # thing — and a caller who passed their OWN solver has already made
+        # this decision inside it.
+        if self.config.expert is not None:
+            solver_kwargs.setdefault("expert", self.config.expert)
         self._solver = solver or CaptchaSolver(**solver_kwargs)
-        self._last_mouse: Tuple[float, float] = (0.0, 0.0)
-        # See _seed_cursor: the (0, 0) origin wedges camoufox's humanised
-        # mouse, so the first move of each solve must step off it plainly.
-        self._cursor_seeded = False
+        #: Every gesture goes through here, and it owns the pointer position.
+        #: See humanize.py — the driver names gestures, this decides what
+        #: events they are and how long they take.
+        self._human: Humanizer = resolve_humanizer(self.config)
         self._last_submit_frame_hash: Optional[str] = None
         # Absolute deadline for the current solve, in the same clock as
         # time.monotonic() * 1000. None outside a solve.
         self._deadline_ms: Optional[float] = None
-        # Window size for clamping, resolved once per solve. See _viewport.
-        self._viewport_cache: Optional[Dict[str, float]] = None
         # Animation detection, all reset per solve by `_reset_animated_state`.
         # `_known_animated` latches: once a widget has been SEEN to animate,
         # every later round takes the keyframe path without re-probing.
         self._known_animated = False
         self._animated_probe_armed = False
         self._animated_probe_done = False
+        # One-shot: the recording path buys its own budget the first time it is
+        # entered, and never again in the same solve. See video_budget_ms.
+        self._video_budget_granted = False
         self._keyframe_mode: Optional[str] = None
         # Repeat detection; see `max_no_progress_rounds`.
         self._last_answer_sig: Optional[str] = None
@@ -500,6 +683,16 @@ class PageSolver:
         # Per-solve phase accounting; see `_phase`.
         self._budget: Optional[PhaseBudget] = None
 
+    @property
+    def _last_mouse(self) -> Tuple[float, float]:
+        """Where the pointer is. Owned by the humanizer, because a mode that
+        dispatches no motion (mobile, between taps) still has to answer this."""
+        return self._human.at
+
+    @_last_mouse.setter
+    def _last_mouse(self, at: Tuple[float, float]) -> None:
+        self._human.at = (float(at[0]), float(at[1]))
+
     @contextmanager
     def _phase(self, name: str):
         """Attribute the enclosed wall-clock to `name` for this solve's budget.
@@ -562,6 +755,7 @@ class PageSolver:
         self._known_animated = False
         self._animated_probe_armed = False
         self._animated_probe_done = False
+        self._video_budget_granted = False
         self._keyframe_mode = None
         self._last_answer_sig: Optional[str] = None
         self._no_progress_rounds = 0
@@ -677,132 +871,12 @@ class PageSolver:
     # Mouse
     # ------------------------------------------------------------------
 
-    def _viewport(self, page: Any) -> Optional[Dict[str, float]]:
-        """
-        The window we must keep the cursor inside, cached per solve.
-
-        MUST NOT be skipped and MUST NOT be guessed, because a mouse move to a
-        coordinate outside the window WEDGES camoufox. Its juggler humanises
-        each move into a trajectory, guards the intermediate points against the
-        bounds, and then dispatches the requested destination unguarded
-        ("Always finish exactly on the requested destination"). An out-of-window
-        destination fires as an exit event instead of eMouseMove, so no
-        hit-renderer ack comes back; dispatch is serialised on a process-global
-        activation chain, so that one missing ack hangs every later input event
-        forever. Symptom: `page.mouse.move()` never returns, 0% CPU, solve
-        appears dead. Same failure family as camoufox #225.
-
-        `page.viewport_size` is None under camoufox (it uses the real window
-        rather than a spoofed viewport), which is why this falls back to asking
-        the page itself instead of assuming a size.
-        """
-        if self._viewport_cache is not None:
-            return self._viewport_cache
-        try:
-            vp = page.viewport_size
-            if callable(vp):  # some adapters expose it as a method
-                vp = vp()
-            if vp and vp.get("width") and vp.get("height"):
-                self._viewport_cache = {"width": float(vp["width"]), "height": float(vp["height"])}
-                return self._viewport_cache
-        except Exception:
-            pass
-        try:
-            inner = page.evaluate("() => ({width: window.innerWidth, height: window.innerHeight})")
-            if inner and inner.get("width") and inner.get("height"):
-                self._viewport_cache = {
-                    "width": float(inner["width"]),
-                    "height": float(inner["height"]),
-                }
-                return self._viewport_cache
-        except Exception:
-            pass
-        return None
-
-    def _trace_path(self, page: Any, points: Sequence[Tuple[float, float]], timings: Sequence[float]) -> None:
-        # Clamp ONLY when the viewport is actually known.
-        #
-        # camoufox reports `viewport_size is None` (it uses the real window
-        # rather than a spoofed viewport). The obvious fallback — assume
-        # 1920x1080 — is actively harmful: it clamps coordinates to the edge of
-        # a viewport that is not the real one, and a coordinate sitting EXACTLY
-        # on the boundary is the input that deadlocks camoufox's humanised-mouse
-        # juggler patch (upstream #225, "humanize edge deadlock"). The symptom is
-        # a `page.mouse.move()` that never returns: the process sits at 0% CPU
-        # with no in-flight work and the solve appears hung, which is precisely
-        # what this driver did against camoufox until this was found.
-        #
-        # A guessed clamp buys nothing anyway — the points come from a
-        # trajectory between two on-screen elements, so they are already in
-        # range. When we do clamp, we inset by a pixel so a legitimately
-        # off-screen point lands just inside the edge instead of exactly on it.
-        viewport = self._viewport(page)
-
-        start = time.monotonic() * 1000.0
-        for i, (x, y) in enumerate(points):
-            try:
-                if viewport is None:
-                    cx, cy = float(x), float(y)
-                else:
-                    cx = max(1.0, min(float(x), float(viewport["width"]) - 1.0))
-                    cy = max(1.0, min(float(y), float(viewport["height"]) - 1.0))
-                page.mouse.move(cx, cy)
-                self._last_mouse = (cx, cy)
-                if i < len(timings):
-                    target = start + timings[i]
-                    _delay(target - time.monotonic() * 1000.0)
-            except Exception as exc:
-                msg = str(exc)
-                if "Target closed" in msg or "Session closed" in msg:
-                    _log("could not move mouse; page or session closed")
-                    return
-                # Any other per-sample failure is skipped rather than fatal —
-                # losing one mousemove must not lose the solve.
-
-    def _seed_cursor(self, page: Any) -> None:
-        """Move the cursor off its (0, 0) origin once per solve, in ONE plain
-        move, before any humanised trajectory runs.
-
-        Without this, the first trajectory of a solve begins at (0, 0) — the
-        exact window corner, because that is where the pointer starts and
-        nothing has moved it. Under camoufox's `humanize` juggler a short move
-        from that origin never returns: `page.mouse.move()` blocks forever at 0%
-        CPU, and since dispatch is serialised on a process-global activation
-        chain, every later input event blocks behind it too. The solve looks
-        hung with no error anywhere and the Tier 3 fixture run times out on all
-        three attempts.
-
-        Reduced to four lines against camoufox directly:
-
-            with Camoufox(headless=True, humanize=True) as b:
-                p = b.new_page(); p.goto("about:blank")
-                p.mouse.move(1.0, 1.0)      # never returns
-
-        The same move after ANY interior move completes in ~1.1s, which is what
-        makes this the fix rather than a workaround: it is the ORIGIN that is
-        poisoned, not the destination. Same failure family as camoufox #225.
-
-        Deliberately not routed through `_smooth_move`: that would generate a
-        trajectory from (0, 0) and reintroduce exactly the move being avoided.
-        """
-        if self._cursor_seeded:
-            return
-        self._cursor_seeded = True
-        vp = self._viewport(page)
-        # Centre when the window is known, else a modest interior point — any
-        # coordinate comfortably off the corner will do.
-        cx, cy = (vp["width"] / 2, vp["height"] / 2) if vp else (200.0, 200.0)
-        try:
-            page.mouse.move(cx, cy)
-            self._last_mouse = (cx, cy)
-        except Exception:  # noqa: BLE001 — an adapter without a mouse must not fail the solve
-            pass
-
     def _smooth_move(self, page: Any, x: float, y: float) -> None:
-        self._seed_cursor(page)
-        points, timings = generate_trajectory(self._last_mouse, (x, y), 60)
+        """Travel to a point. What that MEANS is the humanizer's business — on
+        a touchscreen with no finger down it is a bookkeeping update and emits
+        nothing at all."""
         with self._phase("mouse"):
-            self._trace_path(page, points, timings)
+            self._human.move(page, (x, y))
 
     def _move_to_element(self, page: Any, element: Any, padding_percentage: float = 25.0) -> None:
         # BOUNDED. Playwright's default timeout is 30s, and this is called once
@@ -834,9 +908,8 @@ class PageSolver:
 
     def _move_and_click(self, page: Any, element: Any) -> None:
         self._move_to_element(page, element)
-        page.mouse.down()
-        _delay(random.random() * 20 + 20)
-        page.mouse.up()
+        with self._phase("mouse"):
+            self._human.click(page, self._last_mouse)
 
     def _execute_click(
         self, page: Any, action: Dict[str, Any], element_box: Dict[str, float]
@@ -861,10 +934,8 @@ class PageSolver:
             _log("click action without coordinates or bounding box; skipping")
             return
 
-        self._smooth_move(page, element_box["x"] + rel_x, element_box["y"] + rel_y)
-        page.mouse.down()
-        _delay(random.random() * 30 + 20)
-        page.mouse.up()
+        with self._phase("mouse"):
+            self._human.click(page, (element_box["x"] + rel_x, element_box["y"] + rel_y))
 
     def _execute_drag(
         self, page: Any, action: Dict[str, Any], element_box: Dict[str, float]
@@ -877,12 +948,8 @@ class PageSolver:
 
         src = center(action["source_bounding_box"])
         dst = center(action["target_bounding_box"])
-        self._smooth_move(page, *src)
-        page.mouse.down()
-        _delay(random.random() * 50 + 50)
-        self._smooth_move(page, *dst)
-        _delay(random.random() * 50 + 50)
-        page.mouse.up()
+        with self._phase("mouse"):
+            self._human.drag(page, src, dst)
 
     # ------------------------------------------------------------------
     # Typing and sliding
@@ -906,33 +973,67 @@ class PageSolver:
                 return element
         return None
 
-    def _execute_type(self, page: Any, scope: Any, action: Dict[str, Any]) -> bool:
+    def _answer_box(self, scope: Any, element: Any = None) -> Optional[Any]:
+        """Where a distorted-text captcha's answer goes.
+
+        Inside the widget first. If the widget holds no text box at all, widen
+        ONCE to its enclosing <fieldset>/<form> and look again for a
+        VENDOR-NAMED box only.
+
+        BotDetect is why, and nothing else needs it. BotDetect is a self-hosted
+        LIBRARY, so the host application owns the layout: measured on
+        captcha.com 2026-08-24, `.BDC_CaptchaDiv` — the element `detect_captcha`
+        returns — is 280x50 and holds the image alone, while `#captchaCode` sits
+        in a sibling `<div class="validationDiv">` under the enclosing
+        <fieldset>. Scoped to the widget the solver found no box, `text_mode`
+        stayed False, and it read the code correctly and never typed it. A clean
+        solve thrown away, and indistinguishable in any report from a model that
+        cannot read warped text.
+
+        The widened pass is restricted to TEXT_INPUT_VENDOR_SELECTORS on
+        purpose. The generic tail (`input[type=text]`, `textarea`,
+        `input:not([type])`) is what makes the in-widget lookup work for every
+        other vendor, and OUTSIDE the widget it is exactly how a captcha's
+        answer ends up in a login form's username box — the failure
+        `_find_control`'s docstring already warns about. One level, named
+        selectors, and never the page.
+        """
+        inside = self._find_control(scope, TEXT_INPUT_SELECTORS)
+        if inside is not None or element is None:
+            return inside
+        # Nearest first: a <fieldset> inside a <form> is the tighter box, and
+        # `query_selector` on a union would hand back whichever comes first in
+        # document order — the outer one.
+        for axis in ("ancestor::fieldset[1]", "ancestor::form[1]"):
+            try:
+                host = element.query_selector(f"xpath={axis}")
+            except Exception:
+                continue
+            if host is None:
+                continue
+            found = self._find_control(host, TEXT_INPUT_VENDOR_SELECTORS)
+            if found is not None:
+                _log("widget holds no answer box; using the vendor-named one "
+                     "in its enclosing form")
+                return found
+        return None
+
+    def _execute_type(self, page: Any, scope: Any, action: Dict[str, Any],
+                      element: Any = None) -> bool:
         """Put the model's reading of a distorted-text captcha into its box."""
         text = str(action.get("text") or "")
         if not text:
             return False
-        field = self._find_control(scope, TEXT_INPUT_SELECTORS)
+        field = self._answer_box(scope, element)
         if field is None:
             _log("type action, but no text box in the widget; skipping")
             return False
 
-        self._move_and_click(page, field)  # travel there, then press to focus
-        # A retry round arrives with the previous attempt still in the box, and
-        # typing would APPEND to it — submitting a string the model never read.
-        try:
-            page.keyboard.press("Control+A")
-        except Exception:
-            pass
-        # Per character rather than one `type(text, delay=…)` call: a constant
-        # inter-key delay is itself a signal, and these are the vendors that
-        # score typing cadence.
-        for ch in text:
-            try:
-                page.keyboard.type(ch)
-            except Exception as exc:
-                _log(f"could not type into the captcha field: {exc}")
-                return False
-            _delay(random.random() * 90 + 45)
+        # Tapping the box is what focuses it — and on a phone it is also what
+        # raises the keyboard, so this is not decoration on either device.
+        self._move_and_click(page, field)
+        if not self._human.type_text(page, field, text):
+            return False
         _log(f"typed {len(text)} character(s) into the captcha field")
         return True
 
@@ -949,6 +1050,17 @@ class PageSolver:
             _debug(f"track_piece failed: {exc}")
             return None
 
+    @staticmethod
+    def _shot_scale(shot: str, css_width: float) -> float:
+        """Device pixels per CSS pixel, read off the shot we are about to
+        measure. 1.0 when the image cannot be read — an unreadable shot is
+        already the `_track_piece` returns-None path, and guessing a ratio
+        would steer the handle by it."""
+        dims = _read_png_dimensions(shot)
+        if not dims or css_width <= 0:
+            return 1.0
+        return dims[0] / css_width
+
     def _execute_slide(
         self,
         page: Any,
@@ -1007,12 +1119,12 @@ class PageSolver:
                  + float(action["target_bounding_box"][3])) / 2
             ) * element_box["height"]
             _log("no slider track; dragging the piece to the slot directly")
-            self._smooth_move(page, box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
-            page.mouse.down()
-            _delay(random.random() * 50 + 50)
-            self._smooth_move(page, element_box["x"] + target_x, element_box["y"] + target_y)
-            _delay(random.random() * 50 + 50)
-            page.mouse.up()
+            with self._phase("mouse"):
+                self._human.drag(
+                    page,
+                    (box["x"] + box["width"] / 2, box["y"] + box["height"] / 2),
+                    (element_box["x"] + target_x, element_box["y"] + target_y),
+                )
             return True
 
         hbox = handle.bounding_box()
@@ -1027,7 +1139,7 @@ class PageSolver:
         # moving thing in frame, and we would track the handle instead of the
         # piece.
         pad = max(4.0, hbox["height"] * 0.35)
-        exclude = [
+        band = [
             0.0,
             hbox["y"] - element_box["y"] - pad,
             element_box["width"],
@@ -1037,20 +1149,32 @@ class PageSolver:
         shots = [_tmp_png("slide") for _ in range(4)]
         try:
             self._move_to_element(page, handle, padding_percentage=30.0)
-            page.mouse.down()
-            _delay(random.random() * 60 + 60)
+            self._human.press(page)
+            self._human.pause("grab")
             self._screenshot(element, shots[0],
                              timeout_ms=self.config.element_screenshot_timeout_ms)
 
+            # CSS pixels out here, DEVICE pixels inside the shots. The same
+            # number on a 1x desktop and 2.625x apart on a phone, which is why
+            # this loop measured a slider correctly for a year and then missed
+            # every attempt the moment Tier 3 grew a mobile arm: the mask landed
+            # above the handle, the widths came back 2.6x too wide, and
+            # `_solve_slide_geometry` threw them out as wider than the widget.
+            # Measured from the shot rather than asked of the page, for the same
+            # reason the grid path does it (`_GridSession.scale_x`): what the CV
+            # reads is the image, whatever the window thinks its ratio is.
+            scale = self._shot_scale(shots[0], element_box["width"])
+            exclude = [v * scale for v in band]
+
             probes = self.config.slide_probe_offsets_px
             widths: List[Tuple[float, float]] = []
             last_box = None
             for offset, shot in zip(probes, shots[1:]):
                 self._smooth_move(page, start_x + offset, hold_y)
-                _delay(random.random() * 40 + 40)
+                self._human.pause("probe")
                 box = self._track_piece(element, shots[0], shot, exclude)
                 if box is not None:
-                    widths.append((float(offset), float(box[2] - box[0])))
+                    widths.append((float(offset), float(box[2] - box[0]) / scale))
                     last_box = box
 
             piece_w, ratio = self._solve_slide_geometry(widths, element_box["width"])
@@ -1071,27 +1195,28 @@ class PageSolver:
                 # asked for.
                 offset = float(widths[-1][0])
                 for _ in range(self.config.slide_max_corrections):
-                    piece_center = (last_box[2] - piece_w / 2.0)
+                    piece_center = (last_box[2] / scale - piece_w / 2.0)
                     error = target_x - piece_center
                     if abs(error) <= self.config.slide_tolerance_px:
                         break
                     offset += error / ratio
                     self._smooth_move(page, start_x + offset, hold_y)
-                    _delay(random.random() * 40 + 40)
+                    self._human.pause("probe")
                     box = self._track_piece(element, shots[0], shots[3], exclude)
                     if box is None:
                         break  # ran out of track; release where we are
                     last_box = box
-                _debug(f"slider: piece_w={piece_w:.1f} ratio={ratio:.3f} "
-                       f"final_center={last_box[2] - piece_w / 2.0:.1f} target={target_x:.1f}")
+                _debug(f"slider: piece_w={piece_w:.1f} ratio={ratio:.3f} scale={scale:.3f} "
+                       f"final_center={last_box[2] / scale - piece_w / 2.0:.1f} "
+                       f"target={target_x:.1f}")
 
             # Settle before letting go. A release in the same tick as the last
             # move reads as a machine, and some vendors sample the final
             # milliseconds of the gesture.
-            _delay(random.random() * 120 + 90)
+            self._human.pause("settle")
         finally:
             try:
-                page.mouse.up()
+                self._human.release(page)
             except Exception:
                 pass
             for shot in shots:
@@ -1252,6 +1377,54 @@ class PageSolver:
 
         return None
 
+    def vendors_on_the_wire(self, page: Any) -> List[str]:
+        """Which vendors' code this page actually loaded.
+
+        Read out of the page's own resource timing plus the `src`/`href` of
+        everything it linked, so it works whenever it is called — a request
+        listener would have to have been attached before navigation, and by the
+        time a solve fails that ship has sailed.
+
+        Best-effort by construction: the resource-timing buffer is finite and a
+        page may have cleared it. An empty answer is "nothing seen", never "no
+        captcha here".
+        """
+        try:
+            names = page.evaluate(
+                """() => {
+                  const out = [];
+                  try {
+                    for (const e of performance.getEntriesByType('resource')) out.push(e.name);
+                  } catch (err) {}
+                  for (const el of document.querySelectorAll('script[src],iframe[src],link[href],img[src]')) {
+                    out.push(el.getAttribute('src') || el.getAttribute('href') || '');
+                  }
+                  return out;
+                }"""
+            )
+        except Exception:
+            return []
+        blob = " ".join(str(n) for n in (names or []))
+        return [entry["puzzle_source"] for entry in VENDOR_URL_MARKERS
+                if any(host in blob for host in entry["hosts"])]
+
+    def _no_widget_message(self, page: Any) -> str:
+        """Why nothing was found — the two cases told apart.
+
+        The old text guessed "reCAPTCHA v3 / invisible" every time, including
+        the times a vendor had simply moved its DOM. See VENDOR_URL_MARKERS.
+        """
+        base = "no interactive captcha widget detected"
+        loaded = self.vendors_on_the_wire(page)
+        if not loaded:
+            return (f"{base} (no vendor captcha code loaded on this page — "
+                    "likely reCAPTCHA v3 / invisible, or a click-triggered "
+                    "challenge that has not been triggered)")
+        return (f"{base}, BUT {'/'.join(loaded)} code IS loaded and running on "
+                "this page. The vendor's markup no longer matches anything in "
+                "VENDOR_WIDGET_LOCATORS — re-measure with "
+                "scripts/check_vendor_selectors.py and update BOTH solver ports")
+
     def is_captcha_solved(self, page: Any) -> bool:
         """
         The vendor's definitive DONE signal — anchor checked or token populated.
@@ -1603,13 +1776,59 @@ class PageSolver:
         total = max(1, round(cfg.video_burst_duration_ms / (1000.0 / fps)))
         interval = 1.0 / fps
 
+        # THE ESCALATION BUYS ITS OWN BUDGET, once per solve.
+        #
+        # `overall_solve_timeout_ms` counts rounds, and this is not a round —
+        # see `video_budget_ms` for the arithmetic and for what it cost not to
+        # have it. Granted here rather than where the probe arms because this is
+        # the one place every path into a recording goes through.
+        if cfg.video_solve_enabled and not self._video_budget_granted:
+            self._video_budget_granted = True
+            if self._deadline_ms is not None:
+                self._deadline_ms += cfg.video_budget_ms()
+                _log(f"[animated] +{cfg.video_budget_ms()}ms for the recording path")
+
+        # Checked ONCE, before the first frame — never per frame.
+        #
+        # A HALF-RECORDED BURST IS WORTHLESS: the slicer reads a clip's temporal
+        # structure, so stopping at frame 27 of 40 does not produce a shorter
+        # answer, it produces a recording that may not contain the screen the
+        # answer is on. Aborting mid-way therefore threw away the whole burst
+        # AND the ~3s already spent making it, to report a timeout. The burst is
+        # also fixed-length and short, so it is not one of the places that "can
+        # legitimately spin for a long time" that `_check_deadline` is for.
+        #
+        # If the budget cannot fit one, say THAT — a caller who has tightened
+        # `overall_solve_timeout_ms` below what a recording costs has asked for
+        # something impossible, and should hear it rather than watch a burst die
+        # partway through every time.
+        if self._deadline_ms is not None:
+            left = self._deadline_ms - time.monotonic() * 1000.0
+            if left < cfg.video_burst_duration_ms:
+                raise CaptchaSolveError(
+                    f"only {left:.0f}ms of the {cfg.overall_solve_timeout_ms}ms solve "
+                    f"budget is left and an animated recording needs "
+                    f"{cfg.video_burst_duration_ms}ms — not starting one that would "
+                    f"be cut off mid-way. Raise overall_solve_timeout_ms or "
+                    f"video_extra_inference_ms, or set video_solve_enabled=False."
+                )
+
         frames: List[Any] = []
 
         remaining = max(0, total - len(frames))
         shot = _tmp_png("burst")
+        # A burst that runs far past its own length is a hung screenshot, not a
+        # tight budget — bounded separately so the two cannot be confused.
+        burst_deadline = (time.monotonic() * 1000.0
+                          + 3 * cfg.video_burst_duration_ms + 5_000)
         try:
             for i in range(remaining):
-                self._check_deadline("recording the animated challenge")
+                if time.monotonic() * 1000.0 > burst_deadline:
+                    raise CaptchaSolveError(
+                        f"the animated recording stalled: {i} of {remaining} frames "
+                        f"in {3 * cfg.video_burst_duration_ms + 5000}ms. The widget "
+                        f"is not screenshotting."
+                    )
                 start = time.monotonic()
                 try:
                     # animations ALLOWED — see `_screenshot`. The JS port has
@@ -1924,6 +2143,10 @@ class PageSolver:
         )
 
     def _hover_cell(self, page: Any, session: _GridSession, cell: int) -> None:
+        # A hover is mimicry of a resting CURSOR, so on a device that has none
+        # it is not weaker mimicry — it is a mousemove at a touch-only widget.
+        if not self._human.hovers:
+            return
         first = session.grid_boxes[0]
         cell_w = (first[2] - first[0]) * session.scale_x
         cell_h = (first[3] - first[1]) * session.scale_y
@@ -2135,19 +2358,29 @@ class PageSolver:
             # Each round can legitimately spend ~10s waiting on fades, so eight
             # of them plus the model calls can outlast the whole solve budget.
             self._check_deadline(f"recaptcha grid round {round_index}")
-            with self._phase("grid-load"):
-                self._wait_for_grid_cells_loaded(element)
+            # Round 1 skips it: `_solve_single` has just waited for these cells,
+            # read the grid boxes off the loaded board and handed over, and
+            # nothing has touched the widget in between. Rounds 2..N still wait,
+            # because by then THIS driver has clicked and the tiles really are
+            # reloading. Measured 2148ms x2 on one solve.
+            if round_index > 1:
+                with self._phase("grid-load"):
+                    self._wait_for_grid_cells_loaded(element)
             shot = _tmp_png("recap")
             action: Optional[Dict[str, Any]] = None
             try:
-                self._screenshot(element, shot, timeout_ms=cfg.element_screenshot_timeout_ms)
+                with self._phase("screenshot"):
+                    self._screenshot(element, shot,
+                                     timeout_ms=cfg.element_screenshot_timeout_ms)
                 retry_for_round = pending_retry
                 pending_retry = None  # only round 1 carries the inbound hint
-                actions, usage = self._solve_frame_freshness_guarded(
-                    element,
-                    shot,
-                    lambda image_path: self._get_solution(image_path, "recaptcha", retry_for_round),
-                )
+                with self._phase("inference"):
+                    actions, usage = self._solve_frame_freshness_guarded(
+                        element,
+                        shot,
+                        lambda image_path: self._get_solution(
+                            image_path, "recaptcha", retry_for_round),
+                    )
                 all_usage.extend(usage)
                 action = _as_dict(actions[0]) if actions else None
             finally:
@@ -2160,8 +2393,11 @@ class PageSolver:
 
             if action.get("action") == "wait":
                 _log(f"[recaptcha-grid] round {round_index}: waiting for tiles.")
-                loading, _ = self._watch_clicked_tiles(page, element, session, clicked_order)
-                self._wait_for_any_clicked_tile_loaded(page, element, session, loading)
+                with self._phase("fade-wait"):
+                    loading, _ = self._watch_clicked_tiles(
+                        page, element, session, clicked_order)
+                    self._wait_for_any_clicked_tile_loaded(
+                        page, element, session, loading)
                 continue
 
             if action.get("action") == "click":
@@ -2184,16 +2420,17 @@ class PageSolver:
                     if cell is not None:
                         clicked_order.append(cell)
                         clicked_this_round.append(cell)
-                    _delay(random.random() * 80 + 80)
+                    self._human.pause("between")
                 performed_action = True
                 _log(
                     f"[recaptcha-grid] round {round_index}: clicked {len(bboxes)} tile(s) "
                     f"-> cells {clicked_this_round}."
                 )
 
-                loading, chipped = self._watch_clicked_tiles(
-                    page, element, session, clicked_this_round
-                )
+                with self._phase("fade-wait"):
+                    loading, chipped = self._watch_clicked_tiles(
+                        page, element, session, clicked_this_round
+                    )
                 if chipped or not loading:
                     # Either the widget ticked our clicks and kept the photos
                     # (a board that does that is answered), or nothing faded
@@ -2205,7 +2442,9 @@ class PageSolver:
                     )
                     should_submit = True
                     break
-                self._wait_for_any_clicked_tile_loaded(page, element, session, loading)
+                with self._phase("fade-wait"):
+                    self._wait_for_any_clicked_tile_loaded(
+                        page, element, session, loading)
                 continue
 
             _log(f"[recaptcha-grid] round {round_index}: unexpected action; re-solving.")
@@ -2217,6 +2456,17 @@ class PageSolver:
                 if verify:
                     _log("[recaptcha-grid] clicking Verify to submit.")
                     self._move_and_click(page, verify)
+                    # The press IS an interaction, and saying so is load-bearing
+                    # — the same rule `_solve_single` learned on
+                    # prosopo_grid_3x3, in the other driver, on another day. A
+                    # `done` round clicks no tile, so without this the one
+                    # answer shape that submits and does nothing else reports
+                    # having done nothing: the caller then takes the
+                    # no-interaction wait instead of polling for the verdict
+                    # (~1s of dead time on every static reCAPTCHA), and raises
+                    # "performed no interactions" if the widget has not
+                    # finished tearing down — on an answer correctly sent.
+                    performed_action = True
 
         return performed_action, all_usage
 
@@ -2257,9 +2507,10 @@ class PageSolver:
         # and want opposite answers. Restricted to `unknown` because neither
         # hCaptcha nor reCAPTCHA has ever served a typed challenge, so a match
         # inside one of their frames would be a false positive by definition.
-        text_mode = puzzle_source == "unknown" and self._find_control(
-            scope, TEXT_INPUT_SELECTORS
-        ) is not None
+        text_mode = (
+            puzzle_source not in VENDORS_WITH_BESPOKE_HANDLING
+            and self._answer_box(scope, element) is not None
+        )
         if text_mode:
             _log("widget has a text box; solving as a distorted-text captcha")
 
@@ -2285,7 +2536,7 @@ class PageSolver:
             if self.is_captcha_solved(page):
                 _log("solved while waiting for the next round; skipping inference.")
                 return False, []
-        elif puzzle_source == "unknown":
+        elif puzzle_source not in VENDORS_WITH_BESPOKE_HANDLING:
             # Non-hCaptcha, non-reCAPTCHA widgets (GeeTest, Tencent, …). The settle
             # probe was never run for these, so an animated one — GeeTest's svg board
             # cycles its glyph set — was screenshotted mid-cycle and answered from
@@ -2363,8 +2614,10 @@ class PageSolver:
 
             if not is_animated:
                 if not have_shot:
-                    self._screenshot(element, shot,
-                                     timeout_ms=self.config.element_screenshot_timeout_ms)
+                    with self._phase("screenshot"):
+                        self._screenshot(
+                            element, shot,
+                            timeout_ms=self.config.element_screenshot_timeout_ms)
                 with self._phase("inference"):
                     actions, all_usage = self._solve_frame_freshness_guarded(
                         element,
@@ -2410,7 +2663,7 @@ class PageSolver:
                             if await_kf:
                                 self._wait_for_keyframe(element, await_kf, _bbox_center(bbox))
                             self._execute_click(page, {"target_bounding_box": bbox}, element_box)
-                            _delay(random.random() * 80 + 80)
+                            self._human.pause("between")
                     else:
                         self._execute_click(page, action, element_box)
                     performed_action = True
@@ -2437,7 +2690,7 @@ class PageSolver:
                     performed_action = True
                     placed = True
                 elif kind == "type":
-                    if self._execute_type(page, scope, action):
+                    if self._execute_type(page, scope, action, element):
                         performed_action = True
                         typed = True
                 elif kind == "wait":
@@ -2446,28 +2699,42 @@ class PageSolver:
                         _delay(duration)
                         performed_action = True
 
-                # `scope` when there is no vendor iframe. Eight vendors render
-                # into the HOST PAGE — GeeTest, Yidun, Tencent, Yandex, Lemin,
-                # Prosopo, MTCaptcha, BotDetect — so `content_frame()` is None
-                # for all of them and the button was never even SEARCHED FOR,
-                # while the text box and the slider handle it sits beside were
-                # both found through `scope` a few lines above. Two containers
-                # for two halves of one interaction.
-                #
-                # This used to be gated on `typed`, for fear of turning up the
-                # submit of the FORM the captcha guards. `scope` is the widget
-                # container and the xpaths are RELATIVE, so that button is out
-                # of reach by construction; what the gate actually did was make
-                # every non-typed inline puzzle unsubmittable. Measured on the
-                # Tier 3 fixtures: 4 pairs aborting outright and 11 more types
-                # burning all ten solve loops on a puzzle they had answered on
-                # the first one. The press itself is still bounded by
-                # `should_submit` below, which is where the hazard belongs.
-                lookup = frame or (scope if not slid else None)
-                if lookup is not None:
-                    verify_button = self._get_verify_button(lookup)
-                    if verify_button:
-                        self._move_to_element(page, verify_button)
+
+            # Resolve the widget's submit control AFTER the action loop, not
+            # inside it. An empty plan — the correct answer to reCAPTCHA 3x3's
+            # `none_present` variation, where nothing matches and the control
+            # reads SKIP — never enters that loop, so the lookup never ran, the
+            # press below found `verify_button` None, and the round aborted on
+            # 'performed no interactions'. The finder was never the problem:
+            # 'Skip' has always been in its list. It was simply never called for
+            # the one answer shape that performs no other action.
+            # `scope` when there is no vendor iframe. Eight vendors render
+            # into the HOST PAGE — GeeTest, Yidun, Tencent, Yandex, Lemin,
+            # Prosopo, MTCaptcha, BotDetect — so `content_frame()` is None
+            # for all of them and the button was never even SEARCHED FOR,
+            # while the text box and the slider handle it sits beside were
+            # both found through `scope` a few lines above. Two containers
+            # for two halves of one interaction.
+            #
+            # This used to be gated on `typed`, for fear of turning up the
+            # submit of the FORM the captcha guards. `scope` is the widget
+            # container and the xpaths are RELATIVE, so that button is out
+            # of reach by construction; what the gate actually did was make
+            # every non-typed inline puzzle unsubmittable. Measured on the
+            # Tier 3 fixtures: 4 pairs aborting outright and 11 more types
+            # burning all ten solve loops on a puzzle they had answered on
+            # the first one. The press itself is still bounded by
+            # `should_submit` below, which is where the hazard belongs.
+            # RESOLVED, not travelled to. `_move_and_click` below moves to the
+            # button itself and picks its own random point inside it, so moving
+            # here first bought a second humanised trajectory that ended a few
+            # dozen pixels from where the first one stopped, plus a second
+            # bounded scroll-into-view. Two hops onto one button is slower AND
+            # is not something a hand does. A round that decides not to submit
+            # no longer walks to the control either.
+            lookup = frame or (scope if not slid else None)
+            if lookup is not None:
+                verify_button = self._get_verify_button(lookup)
 
             # Submit policy: press the widget's own submit control whenever we
             # have put an ANSWER into it — a selection, a placed piece, a typed
@@ -2557,8 +2824,7 @@ class PageSolver:
         cumulative_usage: List[Dict[str, Any]] = []
         self._last_submit_frame_hash = None
         self._deadline_ms = start + self.config.overall_solve_timeout_ms
-        self._viewport_cache = None
-        self._cursor_seeded = False
+        self._human.reset(page)
         self._reset_animated_state()
         self._budget = PhaseBudget()
 
@@ -2573,15 +2839,35 @@ class PageSolver:
         # would merge two separate captchas into one attempt — the opposite
         # error, and the one that under-bills.
         previous_session = os.environ.get(_SESSION_ENV)
-        os.environ[_SESSION_ENV] = str(uuid.uuid4())
+        session_id = str(uuid.uuid4())
+        os.environ[_SESSION_ENV] = session_id
+        # The verdict this driver reports back, and it starts FALSE. A solve
+        # that raises never sets it, which is the right default: the widget did
+        # not accept, and the boards that made it raise are exactly the ones
+        # worth keeping. See planner.report_outcome.
+        solved_for_report = False
         try:
-            return self._solve_impl(page, start, cumulative_usage)
+            result = self._solve_impl(page, start, cumulative_usage)
+            # Attached HERE rather than at each of the seven `return
+            # SolveResult(...)` sites, so a new early exit cannot forget it.
+            result.phases = dict(self._budget.totals)
+            result.phases["total"] = self._budget.elapsed_ms()
+            solved_for_report = bool(getattr(result, "is_solved", False))
+            return result
         finally:
             # Printed on the way out of every solve, success or failure — a
             # solve that FAILED is exactly the one whose time you want itemised.
             if timings_enabled() and self._budget is not None:
                 print(self._budget.report(), file=sys.stderr)
             self._deadline_ms = None
+            # BEFORE the env is restored, so the id reported is this solve's.
+            # Best-effort and never raised out of a `finally` — an exception
+            # here would replace the caller's real error, or their real result,
+            # with one about telemetry.
+            try:
+                self._solver.planner.report_outcome(session_id, solved_for_report)
+            except Exception as exc:  # noqa: BLE001
+                _log(f"[outcome] could not report: {exc}")
             if previous_session is None:
                 os.environ.pop(_SESSION_ENV, None)
             else:
@@ -2667,10 +2953,7 @@ class PageSolver:
                     )
                     _delay(800 + random.random() * 300)
                     continue
-                raise NoCaptchaFoundError(
-                    "no interactive captcha widget detected (likely reCAPTCHA v3 / "
-                    "invisible or a click-triggered challenge)"
-                )
+                raise NoCaptchaFoundError(self._no_widget_message(page))
 
             _log(f"--- captcha solve loop {attempt}/{cfg.max_solve_loops} ---")
             retry_mode_this_loop = pending_retry_mode
@@ -2782,60 +3065,74 @@ class PageSolver:
             render_waits = 0
             cumulative_usage.extend(usage)
 
-            if did_interact:
-                # Poll for the vendor's SOLVED signal before re-entering the
-                # pipeline. hCaptcha keeps the challenge visible for a couple of
-                # seconds while verifying; without this the loop re-solves that
-                # closing frame and burns ~18s. Only ever early-RETURNS on a
-                # definitive signal, so it cannot loop.
-                deadline = time.monotonic() * 1000.0 + cfg.post_solve_outcome_timeout_ms
-                solved = False
-                widget_gone = 0
-                _verdict_t0 = time.perf_counter()
-                while time.monotonic() * 1000.0 < deadline:
-                    if self.is_captcha_solved(page):
+            # ONE wait after a round, polled, whichever kind of round it was.
+            #
+            # There used to be two: this poll when the round interacted, and a
+            # flat `_delay(post_solve_delay_ms + jitter)` when it did not. The
+            # flat sleep observed NOTHING — it ran to the end and only then
+            # asked whether the widget was still there — so a round that had in
+            # fact finished the captcha paid 1200-1500ms to find that out. The
+            # poll below already asks exactly that question and answers it the
+            # moment it becomes true.
+            #
+            # The two windows keep different LENGTHS, because different things
+            # size them: `post_solve_outcome_timeout_ms` covers how late a
+            # vendor's success signal can arrive (measured — see the constant),
+            # while `post_solve_delay_ms` is the dwell a round that answered
+            # nothing takes before deciding the page has settled.
+            window_ms = (cfg.post_solve_outcome_timeout_ms if did_interact
+                         else cfg.post_solve_delay_ms + random.random() * 300)
+            # Poll for the vendor's SOLVED signal before re-entering the
+            # pipeline. hCaptcha keeps the challenge visible for a couple of
+            # seconds while verifying; without this the loop re-solves that
+            # closing frame and burns ~18s. Only ever early-RETURNS on a
+            # definitive signal, so it cannot loop.
+            deadline = time.monotonic() * 1000.0 + window_ms
+            solved = False
+            widget_gone = 0
+            _verdict_t0 = time.perf_counter()
+            while time.monotonic() * 1000.0 < deadline:
+                if self.is_captcha_solved(page):
+                    solved = True
+                    break
+                # The eight inline vendors have no response token, so
+                # `is_captcha_solved` — which reads only the hCaptcha and
+                # reCAPTCHA anchors — can never fire for them and this loop
+                # ran out its whole 2.5s budget on EVERY round, waiting for
+                # a signal that cannot arrive. Measured on geetest_v4_slide:
+                # 5.2s of a 12.3s solve, spent after the puzzle was already
+                # answered, with the widget sitting there visibly solved.
+                #
+                # "The widget is gone" is the completion signal for those
+                # vendors and is already the authority immediately after
+                # this loop, so this only reaches the same verdict sooner —
+                # confirmed over two polls so a frame caught mid-swap
+                # between rounds cannot read as a solve.
+                if self.detect_captcha(page) is None:
+                    widget_gone += 1
+                    if widget_gone >= 2:
                         solved = True
                         break
-                    # The eight inline vendors have no response token, so
-                    # `is_captcha_solved` — which reads only the hCaptcha and
-                    # reCAPTCHA anchors — can never fire for them and this loop
-                    # ran out its whole 2.5s budget on EVERY round, waiting for
-                    # a signal that cannot arrive. Measured on geetest_v4_slide:
-                    # 5.2s of a 12.3s solve, spent after the puzzle was already
-                    # answered, with the widget sitting there visibly solved.
-                    #
-                    # "The widget is gone" is the completion signal for those
-                    # vendors and is already the authority immediately after
-                    # this loop, so this only reaches the same verdict sooner —
-                    # confirmed over two polls so a frame caught mid-swap
-                    # between rounds cannot read as a solve.
-                    if self.detect_captcha(page) is None:
-                        widget_gone += 1
-                        if widget_gone >= 2:
-                            solved = True
-                            break
-                    else:
-                        widget_gone = 0
-                    if self._is_challenge_freshly_rendered(page):
-                        break  # next round is up; go solve it now
-                    _delay(cfg.post_solve_outcome_poll_ms)
-                _verdict_ms = (time.perf_counter() - _verdict_t0) * 1000.0
-                if self._budget is not None:
-                    self._budget.add("await-verdict", _verdict_ms)
-                # How long a SUCCESS actually took to show itself. This is the
-                # only number that can size `post_solve_outcome_timeout_ms`: the
-                # window exists to catch a late success, so it needs to cover
-                # the slowest real one and nothing beyond it. A round that ends
-                # any other way spends the whole window by construction — there
-                # is no signal on a wrong answer — so its duration says nothing
-                # about how long the window ought to be.
-                if solved:
-                    _log(f"[verdict] success signal arrived after {_verdict_ms:.0f}ms")
-                if solved:
-                    return SolveResult(True, self._last_mouse, _aggregate(cumulative_usage))
-            else:
-                with self._phase("post-submit-delay"):
-                    _delay(cfg.post_solve_delay_ms + random.random() * 300)
+                else:
+                    widget_gone = 0
+                if self._is_challenge_freshly_rendered(page):
+                    break  # next round is up; go solve it now
+                _delay(cfg.post_solve_outcome_poll_ms)
+            _verdict_ms = (time.perf_counter() - _verdict_t0) * 1000.0
+            if self._budget is not None:
+                self._budget.add(
+                    "await-verdict" if did_interact else "post-submit-delay",
+                    _verdict_ms)
+            # How long a SUCCESS actually took to show itself. This is the
+            # only number that can size `post_solve_outcome_timeout_ms`: the
+            # window exists to catch a late success, so it needs to cover
+            # the slowest real one and nothing beyond it. A round that ends
+            # any other way spends the whole window by construction — there
+            # is no signal on a wrong answer — so its duration says nothing
+            # about how long the window ought to be.
+            if solved:
+                _log(f"[verdict] success signal arrived after {_verdict_ms:.0f}ms")
+                return SolveResult(True, self._last_mouse, _aggregate(cumulative_usage))
 
             if self._has_recaptcha_underselect_error(page):
                 if already_retried_underselect: