@m13v/s4l 1.7.6-rc.2 → 1.7.6-rc.21

package/mcp/menubar/s4l_state.py

@@ -43,10 +43,6 @@ try:
 except Exception:
     pass
 
-# Serializes read-modify-write on approved-queue.json. The menu bar's main thread
-# (approve click / restart resume) and the post-worker thread (status updates)
-# both mutate it; without this a concurrent interleave would drop an approval.
-_approved_lock = threading.Lock()
 
 # Mirrors shared/onboarding-ledger.cjs MILESTONES (same order). The ledger's
 # OPTIONAL milestones (reddit_connected / reddit_verified) are deliberately NOT
@@ -281,19 +277,39 @@ def autopilot_loaded() -> bool:
 _NO_PROXY_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
 
 
+# /health is a trivial constant response, so any real latency is the OWNING MCP
+# process being briefly CPU-starved or paged out under machine load (Nhat's box:
+# ~8.6GB swap, 39% mem pressure, 582 procs), not the endpoint doing work. The old
+# single 1.5s attempt flapped a perfectly-alive server to "unreachable" on one
+# transient stall, and a false negative here strands approved drafts (see the
+# "dead pointer" note in mcp/src/index.ts). So probe forgivingly: a longer
+# deadline plus ONE retry. A genuinely-dead endpoint fails fast either way
+# (ECONNREFUSED returns immediately, both attempts), so this only rescues live
+# servers -- it never lets a real outage look healthy.
+_HEALTH_TIMEOUT_S = 4.0
+_HEALTH_ATTEMPTS = 2
+_HEALTH_RETRY_BACKOFF_S = 0.15
+
+
 def _endpoint_url():
     ep = read_json("panel-endpoint.json")
     url = (ep or {}).get("url")
     if not url:
         return None
-    try:
-        with _NO_PROXY_OPENER.open(url + "health", timeout=1.5) as r:
-            if r.status == 200:
-                return url
-    except Exception as e:
-        sys.stderr.write(f"[s4l-state] loopback health check failed: {type(e).__name__}: {e}\n")
-        sys.stderr.flush()
-        return None
+    last = None
+    for attempt in range(_HEALTH_ATTEMPTS):
+        try:
+            with _NO_PROXY_OPENER.open(url + "health", timeout=_HEALTH_TIMEOUT_S) as r:
+                return url if r.status == 200 else None
+        except Exception as e:
+            last = e
+            if attempt + 1 < _HEALTH_ATTEMPTS:
+                time.sleep(_HEALTH_RETRY_BACKOFF_S)
+    sys.stderr.write(
+        f"[s4l-state] loopback health check failed after {_HEALTH_ATTEMPTS} "
+        f"attempts: {type(last).__name__}: {last}\n"
+    )
+    sys.stderr.flush()
     return None
 
 
@@ -982,89 +998,23 @@ def review_queue_posted_count():
     return sum(1 for c in cands if candidate_state(c) == "posted")
 
 
-def _plan_generation(batch):
-    """created_at of the CURRENT review plan for this batch (stamped by
-    merge_review_queue.py when it starts a fresh plan), or None for plans
-    written before generation stamping existed.
-
-    Why this matters: the plan lives in /tmp and dies on every reboot or tmp
-    sweep, and its candidate numbering restarts at 1, while approved-queue.json
-    lives in the state dir forever. Without a generation marker, ledger entries
-    from a dead plan match the new plan's low indices and every fresh draft is
-    treated as already-decided: the 2026-07-03 "unapproved cards never show up"
-    bug (30 stale entries silently swallowed a whole day of drafts)."""
-    try:
-        p = Path(store_path())
-        if not p.exists():
-            base = os.environ.get("S4L_TMP_DIR") or "/tmp"
-            p = Path(base) / f"twitter_cycle_plan_{batch}.json"
-        return json.loads(p.read_text()).get("created_at") or None
-    except Exception:
-        return None
-
-
-def _ts_before(a, b):
-    """True when iso timestamp a is strictly before b. Tolerates the two stamp
-    shapes in play ('...Z' from merge_review_queue, '+00:00' from time_iso)."""
-    try:
-        import datetime
-
-        def parse(s):
-            return datetime.datetime.fromisoformat(str(s).replace("Z", "+00:00"))
-
-        return parse(a) < parse(b)
-    except Exception:
-        return False
-
-
-def _stale_for_plan(it, gen):
-    """A ledger item that predates the current plan generation refers to a DEAD
-    plan's numbering; its `n` must never match against the live plan."""
-    return bool(gen) and bool(it.get("ts")) and _ts_before(it.get("ts"), gen)
-
-
-def _ledger_items_for_plan(batch, gen):
-    """Decided ledger items that belong to the CURRENT plan generation."""
-    return [
-        it
-        for it in read_approved_queue()["items"]
-        if it.get("batch") == batch
-        and it.get("status") in ("queued", "posting", "posted", "failed", "rejected")
-        and not _stale_for_plan(it, gen)
-    ]
-
-
 def review_drafts(plan, batch="review-queue"):
     """Flatten a plan into the card model: only UNDECIDED candidates. A card that's
     posted, terminal (rejected/dead), or already approved is a settled decision and
     must never be re-presented for review (approved ones proceed to post).
 
-    Also excludes cards with ANY durable decision (approved, edited, rejected, or a
-    decided-but-failed post) via _ledger_items_for_plan() below. approve/reject/edit
-    each write a durable local record via store_stamp_decision() the INSTANT the
-    user clicks (see s4l_menubar.py::_on_card_decision), so a
-    decided card never re-presents even if the loopback (Claude Desktop) is down
-    when the decision's plan-flag write is attempted. The main plan's
-    `approved`/`terminal`/`posted` flags are only stamped once the loopback write
-    lands, so without this a card the user just decided would re-present (the exact
-    "I already decided these" bug)."""
-    gen = (plan or {}).get("created_at") or _plan_generation(batch)
-    items = _ledger_items_for_plan(batch, gen)
-    settled_ids = {
-        it.get("candidate_id") for it in items if it.get("candidate_id") is not None
-    }
-    settled_ns = {it.get("n") for it in items if it.get("candidate_id") is None}
+    Decision durability lives in the store itself: approve/reject/edit each
+    write approved/terminal + the decision payload via store_stamp_decision()
+    the INSTANT the user clicks (see s4l_menubar.py::_on_card_decision), under
+    the store lock, so candidate_state() alone decides what re-presents. The
+    legacy approved-queue.json ledger cross-check that used to live here was
+    removed 2026-07-17 along with the rest of that third state store."""
     out = []
     for i, c in enumerate(((plan or {}).get("candidates") or [])):
         # Only awaiting_review rows become cards. This also skips post_failed
         # rows (decided-but-failed is settled per the docstring above).
         if candidate_state(c) != "awaiting_review":
             continue
-        cid = c.get("candidate_id")
-        if cid is not None and cid in settled_ids:
-            continue
-        if (i + 1) in settled_ns:
-            continue
         out.append(
             {
                 "n": i + 1,  # 1-based, matches post_drafts numbering
@@ -1132,35 +1082,13 @@ def review_drafts(plan, batch="review-queue"):
     return out
 
 
-# ---- durable approved-card queue ------------------------------------------
-# Card approvals MUST survive a menu bar / Claude restart. The in-memory post
-# queue does not: a restart strands every approved-but-unposted card, which then
-# re-presents for approval (the system had no record the user already approved
-# it). This file is the durable record, owned SOLELY by the menu bar — persisting
-# the approval in the main plan instead would race with the autopilot, which
-# rewrites that plan continuously and would silently drop the flag. Status flow:
-# queued -> posting -> posted | failed. review_drafts() excludes queued/posting
-# so an approved card is never re-shown while it drains; a restart re-enqueues
-# queued/posting items instead of re-presenting them.
-APPROVED_QUEUE = "approved-queue.json"
-
-
-def read_approved_queue():
-    d = read_json(APPROVED_QUEUE)
-    if not isinstance(d, dict) or not isinstance(d.get("items"), list):
-        return {"items": []}
-    return d
-
-
-def _write_approved_queue(d):
-    try:
-        p = Path(state_dir()) / APPROVED_QUEUE
-        p.parent.mkdir(parents=True, exist_ok=True)
-        tmp = p.with_suffix(".json.tmp")
-        tmp.write_text(json.dumps(d))
-        os.replace(str(tmp), str(p))  # atomic: a crash never leaves a half file
-    except Exception:
-        pass
+# ---- durable approved-card queue: REMOVED (2026-07-17) ---------------------
+# approved-queue.json was a second local ledger from before the review store
+# stamped decisions durably itself (store_stamp_decision, under the store
+# lock). Once decisions lived in the store, nothing appended to the ledger,
+# every status write was a no-op over a frozen item list, and its read lane
+# re-enqueued dead approvals forever. The review store is the ONLY local
+# decision record now; do not add a second one back.
 
 
 # ---- Engagement mode (2026-06-26, dual-flag 2026-06-29) -------------------
@@ -1422,23 +1350,10 @@ def toggle_lane(lane):
     return write_flags(f["personal_brand"], f["promotion"])
 
 
-def approved_queue_set_status(batch, n, status, error=None):
-    with _approved_lock:
-        d = read_approved_queue()
-        changed = False
-        for it in d["items"]:
-            if it.get("batch") == batch and it.get("n") == n:
-                it.update(status=status, error=error, ts=time_iso())
-                changed = True
-        if changed:
-            _write_approved_queue(d)
-
-
-def approved_queue_pending():
-    """Approvals not yet confirmed posted (queued or posting). Re-enqueued by the
-    menu bar on startup so a restart RESUMES the drain instead of re-presenting."""
-    return [it for it in read_approved_queue()["items"]
-            if it.get("status") in ("queued", "posting")]
+# approved_queue_set_status() / approved_queue_pending() REMOVED (2026-07-17):
+# the legacy approved-queue.json ledger is gone entirely — see the removal note
+# above read-approved-queue's old location. The store lane (store_stamp_decision
+# + store_pending_posts) is the only decision record and resume source now.
 
 
 def post_drafts(batch_id, post=None, edits=None, reject=None, clear_link=None, timeout=900, activity_label=None):

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.6-rc.2",
+  "version": "1.7.6-rc.21",
   "private": true,
   "description": "Desktop MCP client for social-autoposter (X/Twitter rail): manual draft/review/approve loop, autopilot control, and stats. Thin wrapper over the existing pipeline scripts.",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l",
-  "version": "1.7.6-rc.2",
+  "version": "1.7.6-rc.21",
   "description": "Automated social posting pipeline for Reddit, X/Twitter, LinkedIn, and Moltbook. Install as a Claude Code agent skill.",
   "bin": {
     "social-autoposter": "bin/cli.js",

package/scripts/account_resolver.py

@@ -7,6 +7,16 @@ Resolution order for each platform (first non-empty wins):
      checked-in file). Twitter retains the legacy `AUTOPOSTER_TWITTER_HANDLE`
      name as an alias.
   2. The matching field in `config.json` -> `accounts.<platform>.<field>`.
+  3. The platform's durable identity store, when it has one. Today only
+     twitter does: the keychain-independent cookie mirror stamps the live
+     @handle at connect time (see twitter_cookie_mirror). This is the SAME
+     ground truth the session posts through, so it's a safe last resort where
+     a hardcoded fallback would not be. It exists because config.json is not a
+     reliable single home for the handle: onboarding populated the mirror but
+     not always config (the "posts land 0/N, no_account_configured" bug), so
+     making config the ONLY source made it a single point of failure. There is
+     deliberately NO hardcoded default anywhere in this resolver; a missing
+     handle returns None and callers refuse rather than impersonate an account.
 
 The handle is normalized:
   - leading `@` is stripped (twitter)
@@ -81,6 +91,24 @@ def _load_config() -> dict:
         return {}
 
 
+def _durable_handle(key: str) -> Optional[str]:
+    """Best-effort read of the platform's durable identity store, or None.
+
+    The durable store is written once at connect time and survives a fresh
+    install / keychain re-lock / Cookies-DB wipe, so it's the ground-truth last
+    resort when neither env nor config carries the handle. Only twitter has one
+    today (the cookie mirror); other platforms return None (env + config only).
+    Never raises: an unimportable/empty store must not break resolution.
+    """
+    if key in ("twitter", "x"):
+        try:
+            import twitter_cookie_mirror  # optional dep; scripts-dir sibling
+            return normalize((twitter_cookie_mirror.load_meta() or {}).get("handle"))
+        except Exception:
+            return None
+    return None
+
+
 def resolve(platform: str) -> Optional[str]:
     """Return the normalized posting handle for `platform`, or None."""
     key = (platform or "").strip().lower()
@@ -96,7 +124,13 @@ def resolve(platform: str) -> Optional[str]:
     cfg = _load_config()
     accounts = cfg.get("accounts") or {}
     block = accounts.get(section) or {}
-    return normalize(block.get(field))
+    config_value = normalize(block.get(field))
+    if config_value:
+        return config_value
+
+    # Last resort: the durable identity store (twitter cookie mirror). Keeps
+    # config.json from being a single point of failure without ever guessing.
+    return _durable_handle(key)
 
 
 def require(platform: str) -> str:

package/scripts/autopilot_stall_watch.py

@@ -229,7 +229,14 @@ def _recent_batches_not_progressing(min_batches: int = BATCH_PROGRESSION_MIN_BAT
         import http_api  # noqa: E402
 
         resp = http_api.api_get("/api/v1/twitter-batches", {"list": "1", "limit": str(min_batches)})
-        batches = (resp or {}).get("batches") or []
+        # http_api.api_get returns the RAW envelope {"ok":..,"data":{"batches":[..],
+        # "owner_host":..}} — it does NOT unwrap "data". The batches live at
+        # resp["data"]["batches"], never at resp["batches"]. Reading the wrong key
+        # made this return [] -> len<min -> False on EVERY call, so batches_stuck was
+        # hardwired False and the "drafting is not actually happening" stall cause
+        # could never be selected (missed Nhat's 07-15 phase2b-prep pileup entirely).
+        # Do NOT collapse back to resp.get("batches").
+        batches = ((resp or {}).get("data") or {}).get("batches") or []
         if len(batches) < min_batches:
             return False  # not enough history yet to conclude a stall
         return all((b or {}).get("current_phase") not in BATCH_PROGRESSED_PHASES for b in batches)

package/scripts/browser_lifecycle.py

@@ -0,0 +1,90 @@
+"""Shared harness-tab lifecycle: ONE park-on-exit implementation for every
+platform browser lib (twitter_browser.py, reddit_browser.py, future).
+
+Born 2026-07-17 from the user's unification directive: the parking/revive
+discipline lived only in twitter_browser.py, so the reddit harness idled on
+live reddit pages in a visible window and kept its own failure modes. Per
+feedback_minimize_code_footprint there must be exactly one implementation.
+
+Design constraints inherited from the twitter parker (see
+insights_chrome150_renderer_crash_wedge_2026_07_14):
+  - Raw CDP over HTTP+websocket with hard 3s timeouts, NEVER Playwright:
+    at atexit the Playwright loop may be gone, and against a wedged browser
+    this must fail fast, not hang the exit.
+  - suppress_origin: Chrome 111+ rejects ws clients whose Origin header is
+    not in --remote-allow-origins.
+  - Park target is the platform's own /robots.txt, NOT about:blank: a static
+    ~100-byte document with no SPA to leak or crash, whose URL still matches
+    every tab-reuse heuristic (bh list_tabs hides "about:" as internal, and
+    an about:blank park made scans mint new tabs — the proven focus-steal
+    trigger Target.createTarget).
+  - Skip tabs already parked; never raise; S4L_NO_TAB_PARK=1 escape hatch.
+"""
+import atexit
+import json
+import os
+import sys
+import urllib.request
+
+# Loopback CDP must never route through a proxy (macOS system proxy settings
+# leak into urllib's default opener; a box-wide forwarder 403s 127.0.0.1).
+_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+
+_registered = set()
+
+
+def _targets(cdp_base: str):
+    with _OPENER.open(cdp_base.rstrip("/") + "/json/list", timeout=3) as r:
+        return json.loads(r.read())
+
+
+def _navigate_ws(ws_url: str, url: str) -> None:
+    import websocket
+
+    ws = websocket.create_connection(ws_url, timeout=3, suppress_origin=True)
+    try:
+        ws.send(json.dumps({
+            "id": 1, "method": "Page.navigate", "params": {"url": url},
+        }))
+        ws.recv()
+    finally:
+        ws.close()
+
+
+def park_tabs(cdp_base: str, host_markers, park_url: str, label: str) -> None:
+    """Navigate every page tab whose URL matches host_markers to park_url.
+    Best-effort; a wedged browser just fails the 3s connects quietly."""
+    try:
+        for t in _targets(cdp_base):
+            u = t.get("url", "")
+            if t.get("type") != "page":
+                continue
+            if not any(h in u for h in host_markers):
+                continue
+            if u.split("?", 1)[0].rstrip("/").endswith("/robots.txt"):
+                continue  # already parked
+            if not t.get("webSocketDebuggerUrl"):
+                continue
+            try:
+                _navigate_ws(t["webSocketDebuggerUrl"], park_url)
+                print(
+                    f"[{label}] parked tab on {park_url} (was {u[:80]})",
+                    file=sys.stderr,
+                )
+            except Exception:
+                continue
+    except Exception:
+        pass
+
+
+def register_park_on_exit(cdp_base: str, host_markers, park_url: str, label: str) -> None:
+    """Arm park_tabs to run at process exit, once per (endpoint, park_url).
+    Call from a platform lib's get_browser_and_page so only processes that
+    actually used the browser park it."""
+    if os.environ.get("S4L_NO_TAB_PARK"):
+        return
+    key = (cdp_base, park_url)
+    if key in _registered:
+        return
+    _registered.add(key)
+    atexit.register(park_tabs, cdp_base, tuple(host_markers), park_url, label)

package/scripts/cdp_ready_check.py

@@ -1,44 +1,61 @@
 #!/usr/bin/env python3
-"""Real CDP readiness probe for the harness Chrome.
+"""Raw-websocket CDP readiness probe for the harness Chrome.
 
-Exit 0 when a full Playwright connect_over_cdp handshake completes against the
-given CDP URL, 1 when it does not. /json/version alone is a LIVENESS check: a
-wedged Chrome (process alive, HTTP answering, websocket upgrade completing,
-but the browser loop never servicing the CDP session) passes it, and every
-downstream attach then eats Playwright's 180s default timeout while holding
-the browser lock (S4L-4H, Karol 2026-07-11; identical wedge locally 2026-07-09,
-twice, same Chrome instance both times).
+Exit 0 when a real DevTools websocket handshake completes against the given
+CDP URL (browser-level connect + Browser.getVersion round-trip), 1 when it
+does not. /json/version alone is a LIVENESS check: a Chrome whose ws accept
+path died still passes it; this probe exercises the actual session dispatch.
 
-Usage: cdp_ready_check.py [CDP_URL] [TIMEOUT_MS]
+HISTORY — why raw websocket and NOT Playwright (2026-07-17): the original
+probe used sync_playwright().connect_over_cdp. Wedge-diag captures
+(skill/logs/wedge-diag/, v3 discriminator) proved that during every observed
+"wedge" the raw ws handshake completed in <5s while the Playwright connect
+timed out at 20s — with Chrome's DevToolsHandlerThread idle in kevent64 the
+whole time. The stall lives in Playwright's node driver under machine load,
+NOT in Chrome; the Playwright-based verdict was executing a healthy browser
+roughly hourly for days (every cdp_wedge relaunch 07-14..07-17). A probe must
+not depend on machinery heavier than the thing it probes. The S4L-4H /
+Karol-box incidents that motivated the deep probe are equally covered by the
+ws round-trip below (and in hindsight may have been this same client-side
+stall).
+
+Also preserves the renderer-liveness sweep (2026-07-14): a tab whose RENDERER
+crashed ("Aw, Snap") keeps its title/url in every listing while sitting dead;
+probe each page with a trivial Runtime.evaluate and reload it IN PLACE on
+failure — fresh renderer, no kill, no new window, no focus change.
 
-Prints a one-line JSON verdict to stdout so the caller can persist it
-(twitter-backend.sh writes it to skill/logs/cdp-health.json, which
-memory_snapshot.py carries onto the per-minute heartbeat sample).
+Usage: cdp_ready_check.py [CDP_URL] [TIMEOUT_MS]
 
-Falls back to an HTTP-only probe when playwright is not importable under the
-invoking interpreter, so a bare python3 caller degrades to the legacy
-liveness behavior instead of hard-failing.
+Prints a one-line JSON verdict to stdout (same shape/keys as before; mode is
+now "raw_ws"). Falls back to an HTTP-only probe when websocket-client is not
+importable, so a bare python3 caller degrades to liveness instead of failing.
 """
 import json
 import sys
 import time
+import urllib.request
+
+# ProxyHandler({}): loopback CDP must never route through a proxy. macOS
+# system proxy settings leak into urllib's default opener, and a box-wide
+# forwarder 403s 127.0.0.1 probes (2026-07-13 root cause of a "wedged
+# Chrome" misdiagnosis).
+_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+
+
+def _get_json(url: str, timeout: float):
+    with _OPENER.open(url, timeout=timeout) as r:
+        return json.loads(r.read())
 
 
 def main() -> int:
     url = (sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:9555").rstrip("/")
-    timeout_ms = int(sys.argv[2]) if len(sys.argv) > 2 else 8000
+    timeout_s = (int(sys.argv[2]) if len(sys.argv) > 2 else 20000) / 1000.0
     t0 = time.time()
     try:
-        from playwright.sync_api import sync_playwright
+        import websocket  # websocket-client, present in the owned runtime venv
     except Exception:
-        import urllib.request
         try:
-            # ProxyHandler({}): loopback CDP must never route through a proxy.
-            # macOS system proxy settings leak into urllib's default opener, and
-            # a box-wide forwarder 403s 127.0.0.1 probes (2026-07-13 root cause
-            # of the "wedged Chrome" misdiagnosis).
-            opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
-            opener.open(f"{url}/json/version", timeout=3)
+            _OPENER.open(f"{url}/json/version", timeout=3)
             print(json.dumps({"ready": True, "mode": "http-only"}))
             return 0
         except Exception as e:
@@ -46,35 +63,49 @@ def main() -> int:
                 "ready": False, "mode": "http-only", "error": str(e)[:120],
             }))
             return 1
+
+    def _ws_call(ws_url: str, method: str, timeout: float, **params):
+        # suppress_origin: Chrome 111+ rejects ws clients whose Origin header
+        # is not in --remote-allow-origins (same pattern as the tab parker).
+        ws = websocket.create_connection(ws_url, timeout=timeout, suppress_origin=True)
+        try:
+            ws.send(json.dumps({"id": 1, "method": method, "params": params}))
+            deadline = time.time() + timeout
+            while time.time() < deadline:
+                msg = json.loads(ws.recv())
+                if msg.get("id") == 1:
+                    return msg
+            raise TimeoutError(f"no reply to {method}")
+        finally:
+            ws.close()
+
     try:
-        with sync_playwright() as p:
-            browser = p.chromium.connect_over_cdp(url, timeout=timeout_ms)
-            n_contexts = len(browser.contexts)
-            # Renderer-liveness sweep (2026-07-14). A tab whose RENDERER
-            # crashed ("Aw, Snap", error code 5) keeps its normal title/url in
-            # every CDP listing and the browser-level handshake stays green,
-            # so it sat visibly dead for 20+ minutes with nothing entitled to
-            # touch it — below the wedge detector (browser-level) and the
-            # stall guard (scan-progress-level). Probe each page with a
-            # trivial evaluate; on failure reload the tab IN PLACE, which
-            # spawns a fresh renderer. No kill, no new window, no focus
-            # change. Best-effort: revival must never fail the readiness
-            # verdict the wedge gate depends on.
-            revived = 0
-            for ctx in browser.contexts:
-                for page in ctx.pages:
+        # Browser-level handshake: the readiness verdict.
+        info = _get_json(f"{url}/json/version", timeout=3)
+        _ws_call(info["webSocketDebuggerUrl"], "Browser.getVersion", timeout_s)
+
+        # Renderer-liveness sweep: revive crashed tabs in place, best-effort;
+        # revival must never fail the readiness verdict the wedge gate uses.
+        revived = 0
+        pages = []
+        try:
+            pages = [t for t in _get_json(f"{url}/json/list", timeout=3)
+                     if t.get("type") == "page" and t.get("webSocketDebuggerUrl")]
+            for t in pages:
+                try:
+                    _ws_call(t["webSocketDebuggerUrl"], "Runtime.evaluate",
+                             4.0, expression="1")
+                except Exception:
                     try:
-                        page.set_default_timeout(4000)
-                        page.evaluate("1")
+                        _ws_call(t["webSocketDebuggerUrl"], "Page.reload", 8.0)
+                        revived += 1
                     except Exception:
-                        try:
-                            page.reload(timeout=15000, wait_until="commit")
-                            revived += 1
-                        except Exception:
-                            pass
-            browser.close()
+                        pass
+        except Exception:
+            pass
+
         out = {
-            "ready": True, "mode": "cdp", "contexts": n_contexts,
+            "ready": True, "mode": "raw_ws", "contexts": len(pages),
             "elapsed_s": round(time.time() - t0, 2),
         }
         if revived:
@@ -83,7 +114,7 @@ def main() -> int:
         return 0
     except Exception as e:
         print(json.dumps({
-            "ready": False, "mode": "cdp",
+            "ready": False, "mode": "raw_ws",
             "elapsed_s": round(time.time() - t0, 2),
             "error": str(e)[:200].replace("\n", " "),
         }))