oh-my-opencode 4.12.1 → 4.14.0

package/dist/skills/ultimate-browsing/engine/url_transforms.py

@@ -0,0 +1,98 @@
+"""Generic URL transforms for the fetch grid.
+
+Transforms are domain-agnostic *rules*. They never reference a specific
+site by name. A transform either applies (returns a new URL) or is skipped
+(returns None). Callers iterate transforms in order.
+
+Empirically useful transforms (see observations/):
+  * mobile_subdomain — `www.example.com` → `m.example.com`
+    Strong win on SSR sites with mobile-first serving. Loss on SPA shells
+    (some mobile sites return tiny bootstrap HTML).
+  * am_prefix — `example.com` (no www) → `m.example.com`
+  * drop_www — occasionally unblocks hosts that gate www but not apex.
+
+Adding new transforms: prove they help on ≥2 unrelated sites first
+(cross-site validation — bias check).
+"""
+from __future__ import annotations
+
+from typing import Callable, Optional
+from urllib.parse import urlsplit, urlunsplit
+
+
+def _replace_host(url: str, new_host: str) -> str:
+    parts = urlsplit(url)
+    return urlunsplit(parts._replace(netloc=new_host))
+
+
+def _original(url: str) -> Optional[str]:
+    return url
+
+
+def _mobile_subdomain(url: str) -> Optional[str]:
+    """`https://www.example.com/a` → `https://m.example.com/a` (only if host starts with www.)."""
+    parts = urlsplit(url)
+    host = parts.hostname or ""
+    if not host.startswith("www."):
+        return None
+    new_host = "m." + host[4:]
+    if parts.port:
+        new_host = f"{new_host}:{parts.port}"
+    return _replace_host(url, new_host)
+
+
+def _am_prefix(url: str) -> Optional[str]:
+    """`https://example.com/a` → `https://m.example.com/a` (only if host has no subdomain)."""
+    parts = urlsplit(url)
+    host = parts.hostname or ""
+    if not host or host.startswith("m."):
+        return None
+    # Only apply to apex-like hosts (≤2 dot-separated labels).
+    if host.count(".") >= 2 and not host.startswith("www."):
+        return None
+    if host.startswith("www."):
+        return None  # handled by mobile_subdomain
+    return _replace_host(url, "m." + host)
+
+
+def _drop_www(url: str) -> Optional[str]:
+    parts = urlsplit(url)
+    host = parts.hostname or ""
+    if not host.startswith("www."):
+        return None
+    return _replace_host(url, host[4:])
+
+
+TRANSFORMS: dict[str, Callable[[str], Optional[str]]] = {
+    "original": _original,
+    "mobile_subdomain": _mobile_subdomain,
+    "am_prefix": _am_prefix,
+    "drop_www": _drop_www,
+}
+
+
+def apply_transform(name: str, url: str) -> Optional[str]:
+    """Apply one transform by name. Returns transformed URL or None if skipped."""
+    fn = TRANSFORMS.get(name)
+    if fn is None:
+        raise ValueError(f"Unknown transform: {name!r}. Known: {list(TRANSFORMS)}")
+    return fn(url)
+
+
+def iter_transformed(url: str, order: list[str]) -> list[tuple[str, str]]:
+    """Yield (transform_name, transformed_url) pairs for a given order.
+
+    Skips transforms that return None (not applicable) and deduplicates
+    URLs (so `original` and `drop_www` of `https://example.com` don't double-run).
+    """
+    seen: set[str] = set()
+    out: list[tuple[str, str]] = []
+    for name in order:
+        new_url = apply_transform(name, url)
+        if new_url is None:
+            continue
+        if new_url in seen:
+            continue
+        seen.add(new_url)
+        out.append((name, new_url))
+    return out

package/dist/skills/ultimate-browsing/engine/validators.py

@@ -0,0 +1,216 @@
+"""Generic challenge / success validator.
+
+Four layers (all generic, never site-specific):
+  1. Challenge markers (WAF product strings — not site brand names)
+  2. Size fingerprints (known bad byte sizes hinted by caller)
+  3. Cookie sensor state (e.g. Akamai `_abck=~-1~`)
+  4. Caller-supplied success_selectors (strongest positive proof)
+
+Layers 1-3 are "negative proof" (fail fast).
+Layer 4 is "positive proof" — without it, HTTP 200 is only a weak success.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+try:
+    from bs4 import BeautifulSoup
+except ImportError:  # bs4 is a soft dep: only used when selectors given
+    BeautifulSoup = None
+
+
+# Markers are WAF-product strings only. Never include site brand / domain.
+CHALLENGE_MARKERS: list[str] = [
+    "Access Denied",
+    "sec-if-cpt-container",
+    "Powered and protected by Akamai",
+    "Just a moment...",
+    "Checking your browser",
+    "cf-chl-bypass",
+    "Attention Required! | Cloudflare",
+    "<title>Bot Challenge</title>",
+    "DataDome",
+    "captcha",
+    "Please enable JS and disable any ad blocker",
+    "The requested URL was rejected",
+    "Request unsuccessful. Incapsula",
+]
+
+# Minimum body size below which we suspect a stub / challenge page.
+# Tunable: some legitimate short JSON responses may be smaller, but callers
+# that know their response type should pass success_selectors instead.
+SMALL_BODY_THRESHOLD = 3000
+
+
+class Verdict(Enum):
+    """Three-level classification (Codex suggestion — avoid binary)."""
+
+    STRONG_OK = "strong_ok"      # passes all layers incl. success_selectors
+    WEAK_OK = "weak_ok"          # passes 1-3 but no positive proof available
+    CHALLENGE = "challenge"      # fails 1-3 (negative proof triggered)
+    BLOCKED = "blocked"          # non-200 status
+    UNKNOWN = "unknown"          # exception / malformed response
+
+
+@dataclass
+class ValidationResult:
+    verdict: Verdict
+    reasons: list[str] = field(default_factory=list)
+    matched_selectors: list[str] = field(default_factory=list)
+    body_size: int = 0
+    status: int = 0
+
+    @property
+    def ok(self) -> bool:
+        """Kept for ergonomic `if vr.ok:` use — weak_ok counts as ok."""
+        return self.verdict in (Verdict.STRONG_OK, Verdict.WEAK_OK)
+
+    def to_dict(self) -> dict:
+        return {
+            "verdict": self.verdict.value,
+            "reasons": self.reasons,
+            "matched_selectors": self.matched_selectors,
+            "body_size": self.body_size,
+            "status": self.status,
+        }
+
+
+def _marker_hits(body_lower: str) -> list[str]:
+    return [m for m in CHALLENGE_MARKERS if m.lower() in body_lower]
+
+
+def _abck_unresolved(cookies: dict) -> bool:
+    abck = cookies.get("_abck", "")
+    return bool(abck) and "~-1~" in abck
+
+
+def _selector_hits(body: str, selectors: list[str]) -> Optional[list[str]]:
+    """Return matched-selector list, or None if BS4 is unavailable.
+
+    Distinguishing None (dependency missing) from [] (nothing matched) lets
+    the caller classify as UNKNOWN vs CHALLENGE correctly (Codex review: do
+    not let dependency failure masquerade as a WAF outcome).
+    """
+    if BeautifulSoup is None:
+        return None
+    try:
+        soup = BeautifulSoup(body, "html.parser")
+    except Exception:
+        return []
+    hits: list[str] = []
+    for sel in selectors:
+        try:
+            if soup.select(sel):
+                hits.append(sel)
+        except Exception:
+            continue
+    return hits
+
+
+def validate(
+    resp,
+    *,
+    success_selectors: Optional[list[str]] = None,
+    known_bad_sizes: Optional[list[int]] = None,
+    size_tolerance: int = 20,
+) -> ValidationResult:
+    """Validate a `curl_cffi` / `requests` response.
+
+    Parameters
+    ----------
+    resp
+        Response object with `.status_code`, `.text`, and cookie-like access.
+    success_selectors
+        Caller-supplied CSS selectors. Any match promotes `weak_ok` → `strong_ok`.
+        Absence of selectors still allows `weak_ok` (no positive proof, but
+        no negative proof either).
+    known_bad_sizes
+        Byte sizes that have been empirically observed as challenge-page
+        fingerprints (caller / profile hint). NOTE: these values decay over
+        time — profiles should timestamp or refresh them.
+    """
+    try:
+        status = int(getattr(resp, "status_code", 0) or 0)
+        text = getattr(resp, "text", "") or ""
+        size = len(text)
+    except Exception as e:
+        return ValidationResult(verdict=Verdict.UNKNOWN, reasons=[f"parse_error:{e}"])
+
+    r = ValidationResult(verdict=Verdict.UNKNOWN, body_size=size, status=status)
+
+    if status == 0 or status >= 400:
+        r.verdict = Verdict.BLOCKED
+        r.reasons.append(f"status={status}")
+        return r
+
+    # --- Layer 1: challenge markers (product strings, never site brand) ---
+    lowered = text.lower()
+    markers = _marker_hits(lowered)
+    if markers:
+        r.verdict = Verdict.CHALLENGE
+        r.reasons.extend(f"marker:{m}" for m in markers[:3])
+        return r
+
+    # --- Layer 2: size fingerprints (caller hint, tolerant match) ---
+    # Fingerprint match is a strong negative signal — override even selectors.
+    if known_bad_sizes:
+        for bad in known_bad_sizes:
+            if abs(size - bad) <= size_tolerance:
+                r.verdict = Verdict.CHALLENGE
+                r.reasons.append(f"size_fp:{size}~{bad}")
+                return r
+
+    # --- Layer 4 (early): caller's positive proof overrides size heuristic ---
+    # If caller provided selectors, trust their definition of "content exists".
+    # A small page with the required selector is still success.
+    if success_selectors:
+        hits = _selector_hits(text, success_selectors)
+        if hits is None:
+            # BS4 dependency missing — can't evaluate caller's proof.
+            # Classify as UNKNOWN (not CHALLENGE) so a WAF outcome isn't faked.
+            r.verdict = Verdict.UNKNOWN
+            r.reasons.append("bs4_missing")
+            return r
+        if hits:
+            # Cookie sensor state acts as a true gate when selectors passed:
+            # unresolved `_abck` means Akamai did not accept our session even
+            # though the body has our expected selector — trust is weak.
+            cookies = _extract_cookies(resp)
+            r.matched_selectors = hits
+            if _abck_unresolved(cookies):
+                r.reasons.append("abck_unresolved")
+                r.verdict = Verdict.WEAK_OK  # demoted from STRONG_OK
+                return r
+            r.verdict = Verdict.STRONG_OK
+            return r
+        # Selectors requested but none matched → challenge regardless of size.
+        r.verdict = Verdict.CHALLENGE
+        r.reasons.append("no_success_selector")
+        return r
+
+    # No selectors: fall back to size heuristic.
+    if size < SMALL_BODY_THRESHOLD:
+        r.verdict = Verdict.CHALLENGE
+        r.reasons.append(f"tiny_body:{size}")
+        return r
+
+    # --- Layer 3: cookie sensor state (only when no selectors to decide on) ---
+    cookies = _extract_cookies(resp)
+    if _abck_unresolved(cookies):
+        r.reasons.append("abck_unresolved")
+
+    # No positive proof available — weak OK.
+    r.verdict = Verdict.WEAK_OK
+    return r
+
+
+def _extract_cookies(resp) -> dict:
+    try:
+        return {c.name: c.value for c in resp.cookies.jar}
+    except Exception:
+        try:
+            return dict(resp.cookies) if hasattr(resp, "cookies") else {}
+        except Exception:
+            return {}

package/dist/skills/ultimate-browsing/engine/waf_detector.py

@@ -0,0 +1,214 @@
+"""WAF-product detection from a live response.
+
+Returns a *ranking* of (profile_id, confidence) pairs — never a single verdict.
+Single-answer detectors cause cascading wrong plans when misfiring (Codex's
+critique). Planner consumes the ranking and tries top candidates in order.
+
+All detectors operate on WAF-vendor artifacts (cookies / headers / body
+strings) — never site hostnames. See engine/waf_profiles.yaml for the
+profile definitions.
+"""
+from __future__ import annotations
+
+import fnmatch
+import os
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+try:
+    import yaml  # PyYAML
+except ImportError:
+    yaml = None
+
+
+PROFILES_PATH = os.path.join(os.path.dirname(__file__), "waf_profiles.yaml")
+
+
+# In-code safety net — used when waf_profiles.yaml is missing / invalid
+# or PyYAML isn't installed. Keeps fetch() working in a degraded-but-sane
+# mode. Must stay site-agnostic (No-Site-Name Rule).
+_DEFAULT_PROFILES: dict = {
+    "unknown_challenge": {
+        "detectors": {},
+        "confidence_rules": {"strong": 0, "weak": 0},
+        "capabilities_needed": ["needs_js_exec"],
+        "tls_impersonate_candidates": [
+            ["safari", "chrome", "firefox"],
+            ["safari_ios", "chrome_android"],
+        ],
+        "referer_strategies": ["self_root", "google_search", "none"],
+        "url_transform_order": ["original", "mobile_subdomain"],
+        "fallback_when_challenge": ["playwright_mcp", "playwright_real_chrome"],
+        "notes": "in-code default — waf_profiles.yaml unavailable",
+    },
+}
+
+
+# Module-level sticky error. Readers call `last_load_error()` after each
+# `_load_profiles()` call to surface YAML problems in FetchResult.trace.
+_LAST_LOAD_ERROR: Optional[str] = None
+
+
+@dataclass
+class DetectionHit:
+    profile_id: str
+    confidence: float
+    signals: list[str]
+
+
+def last_load_error() -> Optional[str]:
+    """Return the most recent profile-loader error (or None if clean)."""
+    return _LAST_LOAD_ERROR
+
+
+def _load_profiles(path: str = PROFILES_PATH) -> dict:
+    """Load profiles with graceful fallback.
+
+    Never raises. On any failure (PyYAML missing, file missing, parse error,
+    unexpected shape) it returns a copy of `_DEFAULT_PROFILES` and stores
+    the reason in `_LAST_LOAD_ERROR` for the caller to surface.
+    """
+    global _LAST_LOAD_ERROR
+    _LAST_LOAD_ERROR = None
+
+    if yaml is None:
+        _LAST_LOAD_ERROR = "PyYAML not installed — using in-code default profile"
+        return dict(_DEFAULT_PROFILES)
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            loaded = yaml.safe_load(f) or {}
+    except FileNotFoundError:
+        _LAST_LOAD_ERROR = f"waf_profiles.yaml not found at {path}"
+        return dict(_DEFAULT_PROFILES)
+    except yaml.YAMLError as e:
+        _LAST_LOAD_ERROR = f"YAML parse error: {type(e).__name__}: {str(e)[:200]}"
+        return dict(_DEFAULT_PROFILES)
+    except Exception as e:
+        _LAST_LOAD_ERROR = f"profile loader: {type(e).__name__}: {str(e)[:200]}"
+        return dict(_DEFAULT_PROFILES)
+
+    if not isinstance(loaded, dict) or not any(k for k in loaded if not k.startswith("_")):
+        _LAST_LOAD_ERROR = f"waf_profiles.yaml has no usable profiles"
+        return dict(_DEFAULT_PROFILES)
+
+    return loaded
+
+
+def _cookies_dict(resp) -> dict:
+    try:
+        return {c.name: c.value for c in resp.cookies.jar}
+    except Exception:
+        try:
+            return dict(resp.cookies) if hasattr(resp, "cookies") else {}
+        except Exception:
+            return {}
+
+
+def _headers_dict(resp) -> dict:
+    try:
+        return {k.lower(): v for k, v in dict(resp.headers).items()}
+    except Exception:
+        return {}
+
+
+def _match_patterns(haystack_keys: list[str], patterns: list[str]) -> list[str]:
+    """Match literal names or fnmatch patterns (for wildcards like `X-Akamai-*`)."""
+    hits: list[str] = []
+    lowered_keys = [k.lower() for k in haystack_keys]
+    for pat in patterns or []:
+        pat_l = pat.lower()
+        if any(c in pat for c in "*?["):
+            for key in lowered_keys:
+                if fnmatch.fnmatchcase(key, pat_l):
+                    hits.append(pat)
+                    break
+        else:
+            if pat_l in lowered_keys:
+                hits.append(pat)
+    return hits
+
+
+def _score_profile(profile_id: str, profile: dict, resp) -> Optional[DetectionHit]:
+    """Apply profile detectors to resp. Returns hit or None."""
+    if profile_id.startswith("_"):
+        return None
+    detectors = profile.get("detectors") or {}
+    if not detectors and profile_id != "unknown_challenge":
+        return None
+
+    cookies = _cookies_dict(resp)
+    headers = _headers_dict(resp)
+    body = (getattr(resp, "text", "") or "").lower()
+    server = headers.get("server", "")
+
+    signals: list[str] = []
+
+    # Cookie detectors
+    cookie_pats = detectors.get("cookie") or []
+    for hit in _match_patterns(list(cookies.keys()), cookie_pats):
+        signals.append(f"cookie:{hit}")
+
+    # Header detectors
+    header_pats = detectors.get("header") or []
+    for hit in _match_patterns(list(headers.keys()), header_pats):
+        signals.append(f"header:{hit}")
+
+    # Server substring
+    for needle in detectors.get("server_contains") or []:
+        if needle.lower() in server:
+            signals.append(f"server:{needle}")
+
+    # Body markers
+    for needle in detectors.get("body") or []:
+        if needle.lower() in body:
+            signals.append(f"body:{needle}")
+
+    if not signals:
+        return None
+
+    rules = profile.get("confidence_rules") or {"strong": 2, "weak": 1}
+    n = len(signals)
+    if n >= rules.get("strong", 2):
+        conf = 0.9
+    elif n >= rules.get("weak", 1):
+        conf = 0.6
+    else:
+        conf = 0.3
+
+    return DetectionHit(profile_id=profile_id, confidence=conf, signals=signals)
+
+
+def detect(resp, *, profiles: Optional[dict] = None, min_confidence: float = 0.0) -> list[DetectionHit]:
+    """Return ranked list of detection hits (best first).
+
+    When nothing fires, the returned list contains a single `unknown_challenge`
+    hit with confidence 0.1 — caller can use its conservative settings.
+    """
+    if profiles is None:
+        profiles = _load_profiles()
+
+    hits: list[DetectionHit] = []
+    for profile_id, profile in profiles.items():
+        if profile_id.startswith("_"):
+            continue
+        h = _score_profile(profile_id, profile, resp)
+        if h and h.confidence >= min_confidence:
+            hits.append(h)
+
+    hits.sort(key=lambda x: x.confidence, reverse=True)
+
+    if not hits:
+        hits.append(DetectionHit(
+            profile_id="unknown_challenge",
+            confidence=0.1,
+            signals=["fallback"],
+        ))
+    return hits
+
+
+def load_profile(profile_id: str, *, profiles: Optional[dict] = None) -> dict:
+    """Get one profile by id, resolving `unknown_challenge` if missing."""
+    if profiles is None:
+        profiles = _load_profiles()
+    return profiles.get(profile_id) or profiles.get("unknown_challenge") or {}

package/dist/skills/ultimate-browsing/engine/waf_profiles.yaml

@@ -0,0 +1,162 @@
+# WAF Product Profiles — never site-specific.
+#
+# NO-SITE-NAME RULE:
+#   * Key names are WAF products (akamai_bot_manager), not sites.
+#   * Detectors use product artifacts (cookies / headers / vendor strings).
+#   * Field values (markers, cookie names) must appear in any site running
+#     that WAF, not just one. If a value only fits one site, it belongs
+#     to runtime hints / observations, not this file.
+#
+# Profiles are *recommendations*, not deterministic recipes. The planner
+# treats them as priors; attempts always evaluate real responses.
+#
+# Timestamp each profile entry. If stale (> 6 months), cross-validate.
+
+_meta:
+  schema_version: 1
+  last_reviewed: "2026-04-21"
+
+akamai_bot_manager:
+  detectors:
+    cookie: ["_abck", "bm_sz", "ak_bmsc", "bm_sv", "bm_so"]
+    header: ["X-Akamai-*"]
+    server_contains: ["AkamaiGHost"]
+    body: ["sec-if-cpt-container", "Powered and protected by Akamai"]
+  confidence_rules:
+    # Multi-signal gating — single marker insufficient.
+    strong: 2     # any 2 signals from above → confidence 0.9
+    weak: 1       # 1 signal → confidence 0.6
+  capabilities_needed:
+    - needs_real_tls_stack   # Playwright Chromium (BoringSSL) is detected
+    - needs_js_exec          # 2.6KB challenge requires JS sensor
+  tls_impersonate_candidates:
+    # Every impersonate target curl_cffi supports that historically yielded
+    # at least a challenge page (i.e. IP still alive) rather than an outright
+    # TLS reject. Grouped by family; planner tries top groups first.
+    # Refresh quarterly — vendor WAFs shift which TLS fingerprints they trust.
+    - [safari, safari15_3, safari15_5, safari17_0, safari260]
+    - [safari_ios, safari17_2_ios, safari260_ios]
+    - [chrome99, chrome100, chrome101, chrome104, chrome110, chrome116, chrome119, chrome124, chrome131, chrome133a, chrome136, chrome145, chrome146]
+    - [chrome_android, chrome131_android]
+    - [edge99, edge101]
+  tls_impersonate_avoid:
+    # Empirically observed to 403 immediately (TLS fingerprint blacklisted).
+    # DO NOT hard-block — planner deprioritizes only. Refresh quarterly.
+    - safari18_0
+    - chrome107
+    - chrome120
+    - chrome123
+    - chrome145     # curl_cffi 0.11+ needed — mark avoid for older installs
+    - chrome146
+    - firefox
+    - firefox133
+    - firefox135
+  referer_strategies:
+    - self_root    # scheme://host/
+  url_transform_order:
+    - original
+    - mobile_subdomain   # www.* → m.* — strong observational win in SSR sites
+  fallback_when_challenge:
+    - curl_grid_exhaust   # try more impersonate × referer × url combos
+    - playwright_real_chrome
+  notes: |
+    DO NOT encode site-specific selectors or byte-size fingerprints here.
+    Those belong to caller's success_selectors param or observations log.
+
+cloudflare_turnstile:
+  detectors:
+    cookie: ["cf_clearance", "__cf_bm", "__cfduid"]
+    header: ["cf-ray", "cf-cache-status"]
+    server_contains: ["cloudflare"]
+    body: ["Just a moment...", "Checking your browser", "cf-chl-bypass", "Attention Required! | Cloudflare"]
+  capabilities_needed:
+    - needs_js_exec        # MCP Playwright Chromium OK — no real-TLS required
+  tls_impersonate_candidates:
+    - [chrome, chrome_android]
+  referer_strategies:
+    - google_search
+    - self_root
+  fallback_when_challenge:
+    - playwright_mcp       # MCP sufficient; Chromium TLS passes CF baseline
+    - playwright_real_chrome
+
+f5_big_ip:
+  detectors:
+    cookie: ["BigIPServer", "TS01*", "F5_*"]
+    body: ["The requested URL was rejected", "support ID is:"]
+  capabilities_needed:
+    - needs_real_tls_stack
+  tls_impersonate_candidates:
+    - [safari, chrome]
+  referer_strategies:
+    - self_root
+
+aws_waf:
+  detectors:
+    cookie: ["aws-waf-token"]
+    header: ["x-amzn-requestid", "x-amzn-errortype", "x-amzn-waf-*"]
+  capabilities_needed:
+    - needs_real_tls_stack
+  tls_impersonate_candidates:
+    - [chrome]
+  referer_strategies:
+    - self_root
+
+datadome_probable:
+  detectors:
+    cookie: ["datadome"]
+    body: ["DataDome"]
+  capabilities_needed:
+    - needs_real_tls_stack
+    - needs_js_exec
+  tls_impersonate_candidates:
+    - [safari, chrome]
+  fallback_when_challenge:
+    - playwright_real_chrome
+  notes: |
+    "_probable" suffix reminds us this is a growing attack surface — mark
+    as tentative until cross-site evidence accumulates in observations/.
+
+perimeterx_human:
+  detectors:
+    cookie: ["_px3", "_pxhd", "_px2", "pxcts"]
+    body: ["px-captcha", "Press & Hold to confirm you are a human"]
+  capabilities_needed:
+    - needs_real_tls_stack
+    - needs_js_exec
+  tls_impersonate_candidates:
+    - [safari, chrome]
+  fallback_when_challenge:
+    - playwright_real_chrome
+  notes: |
+    PerimeterX (now HUMAN Bot Defender). Distinct cookie family from
+    DataDome. Keep profiles separate so planner does not pick wrong
+    fallback strategy.
+
+# ---------------------------------------------------------------------------
+# Safety net: always-valid fallback profile.
+# ---------------------------------------------------------------------------
+unknown_challenge:
+  detectors: {}   # never matches actively — used only when no other profile fires
+  confidence_rules:
+    strong: 0
+    weak: 0
+  capabilities_needed:
+    - needs_js_exec     # conservative default
+  tls_impersonate_candidates:
+    - [safari, chrome, firefox]
+    - [safari_ios, chrome_android]
+  referer_strategies:
+    - self_root
+    - google_search
+    - none
+  url_transform_order:
+    - original
+    - mobile_subdomain
+  fallback_when_challenge:
+    - playwright_mcp
+    - playwright_real_chrome
+  notes: |
+    When detector returns low-confidence results we land here. Broad,
+    conservative grid. Evidence from these runs should feed observations/
+    for eventual profile promotion.