@m13v/s4l 1.7.7-rc.7 → 1.7.7-rc.8

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.7-rc.7",
-  "installedAt": "2026-08-02T22:02:14.223Z"
+  "version": "1.7.7-rc.8",
+  "installedAt": "2026-08-03T22:41:58.148Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.7-rc.7",
+  "version": "1.7.7-rc.8",
   "description": "Draft, review, approve, and autopilot X/Twitter posts.",
   "long_description": "## **⚠️ The disclaimer above is generic Claude boilerplate.** Anthropic shows the same warning on every plugin regardless of what it does; any plugin has the same level of access as any app you download from the internet.\n\nS4L is an open source product developed by Mediar.ai Incorporated, a VC-backed San Francisco-based startup.\n\nTo get started:\n\n1\\. Copy this prompt: **Set me up on S4L plugin end to end**\n\n2\\. Quit with CMD+Q, reopen Claude, paste into a new chat.\n\nWhat happens next:\n\n* About every 5 minutes S4L scans X for posts that match your topics and drafts replies in your voice.\n* Drafts show up as review cards, usually the first within a few minutes. Nothing is posted automatically; you approve each one.\n* Posting autopilot stays off until you explicitly turn it on.",
   "author": {

package/mcp/menubar/s4l_card.py

@@ -1964,7 +1964,12 @@ class _ReviewController(NSObject):
         """NSTimer target (2026-07-15): re-renders the header's age/expiry
         label every second so its countdown visibly counts down without
         needing hover. Not a python_method -- NSTimer invokes this through
-        the ObjC runtime."""
+        the ObjC runtime. No-op when the rendered text is unchanged: the
+        label usually shows a coarse "3h"-style value that only changes
+        every few minutes, and unconditionally re-styling it dirtied one
+        layer per tile per second -- with a 130-tile canvas that was a
+        constant CoreAnimation commit churn keeping the app at ~15% CPU
+        while idle (2026-08-02 lag incident)."""
         if self._age_expiry_label is None:
             return
         try:
@@ -1975,6 +1980,9 @@ class _ReviewController(NSObject):
             )
             if not text:
                 return
+            if (text, urgent) == getattr(self, "_age_expiry_last", None):
+                return
+            self._age_expiry_last = (text, urgent)
             self._age_expiry_label.setStringValue_(text)
             self._age_expiry_label.setFont_(_font(11, urgent))
             self._age_expiry_label.setTextColor_(

package/mcp/menubar/s4l_card_canvas.py

@@ -461,14 +461,13 @@ class _CanvasController(NSObject):
 
     @objc.python_method
     def _reflow_from(self, start_idx):
-        """Rebuild every slot's CONTENT from start_idx onward from the
-        current self._order -- slot POSITIONS never move, only which draft
-        occupies each one. Used after a decision removes one entry so
-        everything after it shifts into the vacated grid position ("snake"
-        reflow, 2026-07-16 user direction) instead of independently
-        refilling in place. In-progress edits on any rebuilt tile are lost
-        -- ranking order takes priority over preserving an edit on a card
-        the reviewer hadn't yet acted on."""
+        """Build every slot's CONTENT from start_idx onward from the current
+        self._order. Only two callers: the initial grid build (start 0) and
+        extend_drafts (start = old length, so only the NEW empty slots get
+        content). Decisions no longer come through here -- rebuilding ~130
+        full tile views per click was the dominant cost of an approval on a
+        big backlog (2026-08-02 lag incident, second act); _remove_and_reflow
+        now MOVES the surviving slot views instead."""
         for i in range(start_idx, len(self._slots)):
             slot = self._slots[i]
             for sv in list(slot["view"].subviews()):
@@ -476,8 +475,8 @@ class _CanvasController(NSObject):
             d = self._order[i]
             tile = _ReviewController.alloc().initWithDrafts_onDecision_onComplete_focus_hostView_hostWindow_(
                 [d],
-                self._tile_decision_cb(i),
-                self._tile_complete_cb(i),
+                self._tile_decision_cb(slot),
+                self._tile_complete_cb(slot),
                 True,
                 slot["view"],
                 self._panel,
@@ -487,19 +486,23 @@ class _CanvasController(NSObject):
 
     @objc.python_method
     def _remove_and_reflow(self, n):
-        """Pop draft `n` out of self._order, drop one slot (the grid is one
-        shorter -- no spare capacity to backfill), and reflow every slot
-        from its old position onward so subsequent cards shift up into the
-        gap in rank order."""
+        """Pop draft `n` out of self._order, drop ITS slot (view and all),
+        and shift every later slot's VIEW up into the vacated grid position
+        ("snake" reflow, 2026-07-16 user direction). Positions move, content
+        doesn't: each surviving tile keeps its live view -- O(N) setFrame
+        calls instead of O(N) full tile rebuilds (2026-08-02 lag fix), and
+        an in-progress edit on a later card now survives earlier decisions
+        instead of being clobbered by the rebuild."""
         try:
             idx = next(i for i, d in enumerate(self._order) if d.get("n") == n)
         except StopIteration:
             return
         self._order.pop(idx)
-        if self._slots:
-            last = self._slots.pop()
-            last["view"].removeFromSuperview()
-        self._reflow_from(idx)
+        if idx < len(self._slots):
+            gone = self._slots.pop(idx)
+            gone["view"].removeFromSuperview()
+        for i in range(idx, len(self._slots)):
+            self._slots[i]["view"].setFrame_(self._slot_frame(i))
         self._resize_doc()
         self._refresh_header()
         # Last card decided -> nothing left to review, so close the canvas
@@ -535,7 +538,7 @@ class _CanvasController(NSObject):
             _log(f"canvas discard-all handler failed: {e}")
 
     @objc.python_method
-    def _tile_decision_cb(self, slot_idx):
+    def _tile_decision_cb(self, slot):
         def _cb(decision):
             self._decisions.append(decision)
             self._last_decision_at = time.time()
@@ -549,16 +552,16 @@ class _CanvasController(NSObject):
         return _cb
 
     @objc.python_method
-    def _tile_complete_cb(self, slot_idx):
+    def _tile_complete_cb(self, slot):
         def _cb(_tile_decisions):
             # The tile's own single-draft stack finished -- remove it from
             # the ranking and let everything after it shift up ("snake"
-            # reflow; see _remove_and_reflow). slot_idx is read lazily at
-            # call time (not captured as a fixed n) because a still-live
-            # tile ahead of it could have already shifted this slot's
-            # content since the closure was created.
-            slot = self._slots[slot_idx] if slot_idx < len(self._slots) else None
-            n = slot["n"] if slot else None
+            # reflow; see _remove_and_reflow). Closing over the SLOT DICT
+            # (not a positional index) keeps the lookup correct no matter
+            # how many earlier slots have been popped since this closure
+            # was created: a slot keeps its `n` for life now that reflow
+            # moves views instead of rebuilding content.
+            n = slot["n"]
             if n is not None:
                 self._remove_and_reflow(n)
 

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.7-rc.7",
+  "version": "1.7.7-rc.8",
   "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.7-rc.7",
+  "version": "1.7.7-rc.8",
   "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/browser_lifecycle.py

@@ -77,6 +77,36 @@ def park_tabs(cdp_base: str, host_markers, park_url: str, label: str) -> None:
         pass
 
 
+def background_new_page(browser, context, url: str = "about:blank", timeout_ms: int = 10_000):
+    """Create a Playwright page WITHOUT raising the Chrome window.
+
+    Playwright's context.new_page() maps to a FOREGROUND Target.createTarget,
+    which activates Chrome on macOS and steals app focus (the July 2026
+    focus-steal class; same call the bh helpers and the harness daemon were
+    already fixed to avoid). Playwright's public API has no background
+    option, so this creates the target via a browser-level CDP session with
+    background:true and returns the Page that `context` adopts for it.
+
+    ONE shared implementation for every attach path that previously called
+    context.new_page() on the harness (reddit_browser, twitter_browser,
+    reddit_browser_fetch). Falls back to context.new_page() if the CDP path
+    fails: a rare focus blip beats a dead pipeline.
+    """
+    try:
+        cdp = browser.new_browser_cdp_session()
+        try:
+            with context.expect_page(timeout=timeout_ms) as pg_info:
+                cdp.send("Target.createTarget", {"url": url, "background": True})
+            return pg_info.value
+        finally:
+            try:
+                cdp.detach()
+            except Exception:
+                pass
+    except Exception:
+        return context.new_page()
+
+
 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

package/scripts/harness_target_monitor.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""Attribution monitor for harness-Chrome focus steals (2026-08-03).
+
+Connects to a harness Chrome's browser-level CDP websocket, enables target
+discovery, and appends one timestamped line per Target lifecycle event
+(created / destroyed / info-changed => navigations) to a log file. Correlate
+these against the `[browser-foreground]` activation lines in
+~/.social-autoposter-mcp/menubar/menubar.err.log to attribute WHICH tab
+operation coincided with an app activation, something none of the existing
+logs capture (the daemon log has no timestamps; python new_page sites have
+no logging at all; bh [bh_tab_event] covers only the bh lanes).
+
+Read-only: never creates, closes, or navigates anything.
+
+Usage:
+    harness_target_monitor.py [--port 9557] [--log PATH]
+
+Runs forever; reconnects with backoff when Chrome restarts. Intended to run
+under nohup during a diagnosis window. It is NOT part of the pipeline.
+"""
+import argparse
+import json
+import os
+import sys
+import time
+from datetime import datetime, timezone
+
+
+def ts() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+
+def log_line(path: str, msg: str) -> None:
+    with open(path, "a") as f:
+        f.write(f"[{ts()}] {msg}\n")
+
+
+def monitor_once(port: int, log_path: str) -> None:
+    import urllib.request
+    import websocket
+
+    opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+    info = json.loads(opener.open(f"http://127.0.0.1:{port}/json/version", timeout=3).read())
+    ws = websocket.create_connection(
+        info["webSocketDebuggerUrl"], timeout=5, suppress_origin=True
+    )
+    try:
+        ws.send(json.dumps({"id": 1, "method": "Target.setDiscoverTargets",
+                            "params": {"discover": True}}))
+        log_line(log_path, f"monitor attached port={port} chrome={info.get('Browser','?')}")
+        ws.settimeout(60)
+        last_url = {}
+        while True:
+            try:
+                msg = json.loads(ws.recv())
+            except Exception as e:
+                if "timed out" in str(e).lower():
+                    # Idle is fine; poke the connection so a dead Chrome errors out.
+                    ws.send(json.dumps({"id": 2, "method": "Browser.getVersion"}))
+                    continue
+                raise
+            method = msg.get("method", "")
+            p = msg.get("params", {})
+            t = p.get("targetInfo", {})
+            if t.get("type") not in ("page", ""):
+                continue
+            tid = t.get("targetId") or p.get("targetId", "?")
+            url = t.get("url", "")
+            if method == "Target.targetCreated":
+                log_line(log_path, f"CREATED  {tid} url={url[:100]}")
+            elif method == "Target.targetDestroyed":
+                log_line(log_path, f"DESTROYED {tid} (last_url={last_url.get(tid, '?')[:100]})")
+            elif method == "Target.targetInfoChanged":
+                if url and url != last_url.get(tid):
+                    log_line(log_path, f"NAVIGATED {tid} url={url[:100]}")
+            if tid != "?" and url:
+                last_url[tid] = url
+    finally:
+        try:
+            ws.close()
+        except Exception:
+            pass
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--port", type=int, default=9557)
+    ap.add_argument("--log", default=os.path.expanduser(
+        "~/social-autoposter/skill/logs/harness-target-events-9557.log"))
+    args = ap.parse_args()
+    while True:
+        try:
+            monitor_once(args.port, args.log)
+        except KeyboardInterrupt:
+            return 0
+        except Exception as e:
+            try:
+                log_line(args.log, f"monitor disconnected ({type(e).__name__}: {str(e)[:120]}); retry in 15s")
+            except OSError:
+                pass
+            time.sleep(15)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/reddit_browser.py

@@ -441,7 +441,11 @@ def _get_browser_and_page_raw(playwright):
                         return cdp_browser, pg, True
                 if chosen.pages:
                     return cdp_browser, chosen.pages[0], True
-                page = chosen.new_page()
+                # Zero pages: create in the BACKGROUND (2026-08-03). A plain
+                # new_page() here is a foreground Target.createTarget, which
+                # activates Chrome and steals macOS app focus.
+                from browser_lifecycle import background_new_page
+                page = background_new_page(cdp_browser, chosen)
                 return cdp_browser, page, True
             # No usable context: do NOT close the CDP browser (would kill the
             # harness Chrome); just disconnect by falling through.
@@ -464,13 +468,15 @@ def _get_browser_and_page_raw(playwright):
                     for c in cookies
                 )
                 if has_session:
-                    # Reuse an existing tab (no focus-steal); only new_page if none.
+                    # Reuse an existing tab (no focus-steal); only create if none,
+                    # and then in the BACKGROUND (2026-08-03, see above).
                     for pg in ctx.pages:
                         if "reddit.com" in (pg.url or "") and "login" not in (pg.url or ""):
                             return cdp_browser, pg, True
                     if ctx.pages:
                         return cdp_browser, ctx.pages[0], True
-                    page = ctx.new_page()
+                    from browser_lifecycle import background_new_page
+                    page = background_new_page(cdp_browser, ctx)
                     return cdp_browser, page, True
             try:
                 cdp_browser.close()

package/scripts/reddit_browser_fetch.py

@@ -165,7 +165,11 @@ def browser_get_json(url, cdp_url=None, timeout_ms=25000):
                 if page is None and ctx.pages:
                     page = ctx.pages[0]
                 if page is None:
-                    page = ctx.new_page()
+                    # Zero pages: create in the BACKGROUND (2026-08-03). A plain
+                    # new_page() is a foreground Target.createTarget, which
+                    # activates Chrome and steals macOS app focus.
+                    from browser_lifecycle import background_new_page
+                    page = background_new_page(browser, ctx)
                 # Load the matching host root so the subsequent fetch() is same-origin
                 # (no CORS between www/old) and carries the logged-in session.
                 try:

package/scripts/reddit_tools.py

@@ -74,71 +74,61 @@ def _wait_if_needed():
 def _fetch_via_browser(url):
     """Fetch a Reddit URL through the reddit-harness logged-in Chrome.
 
-    Returns the raw response body (str) on HTTP 200, else None so the caller
-    falls back to urllib. This is the 2026-05-29 transport swap: Reddit began
-    403ing urllib/curl on *.json from residential IPs on 2026-05-28, but a
-    same-origin fetch() from inside the logged-in harness browser returns 200.
-
-    Gated by REDDIT_FETCH_BACKEND: default ("harness") uses the browser first;
-    set REDDIT_FETCH_BACKEND=urllib to force the legacy path (e.g. for debugging).
-    Also short-circuits to None when REDDIT_CDP_URL is unset AND no harness is
-    expected, so plain `urllib`-only environments are unaffected.
+    Browser-ONLY transport (2026-08-03, user decision: no urllib fallback).
+    Reddit's TLS-fingerprint wall (2026-05-28) 403s urllib/curl on *.json
+    unconditionally, so the old fallback could never succeed: it burned ~2s
+    per browser hiccup and then lost the query anyway. Transient failures
+    (Reddit 503s, harness contention) get ONE in-transport retry instead.
+    The REDDIT_FETCH_BACKEND=urllib debug knob is gone for the same reason:
+    forcing a transport that is guaranteed to 403 debugs nothing.
+
+    Returns the raw response body (str) on HTTP 200. Raises on final failure,
+    urllib.error.HTTPError for HTTP statuses and urllib.error.URLError for
+    transport-level failures, matching the exception shapes callers already
+    handle from the urllib era. 429 keeps the old inline-wait contract
+    (absorb a short wait, else RateLimitedError).
     """
-    if os.environ.get("REDDIT_FETCH_BACKEND", "harness").lower() == "urllib":
-        return None
-    try:
-        from reddit_browser_fetch import browser_get_json
-    except Exception as e:
-        sys.stderr.write(f"[reddit_tools] browser fetch unavailable ({e}); urllib fallback\n")
-        return None
-    try:
+    from reddit_browser_fetch import browser_get_json
+
+    last_status = 0
+    for attempt in (1, 2):
         body, status = browser_get_json(url)
         if status == 200 and body:
             return body
-        sys.stderr.write(f"[reddit_tools] browser fetch status={status} for {url[:80]}; urllib fallback\n")
-    except Exception as e:
-        sys.stderr.write(f"[reddit_tools] browser fetch error ({e}); urllib fallback\n")
-    return None
+        last_status = status
+        if status == 429:
+            # Browser transport exposes no X-Ratelimit-Reset header; assume
+            # Reddit's standard 60s window.
+            _write_ratelimit(0, 60)
+            if 60 > MAX_INLINE_WAIT_SECONDS:
+                raise RateLimitedError(60)
+            if attempt == 1:
+                print("Rate limited. Waiting 62s...", file=sys.stderr)
+                time.sleep(62)
+            continue
+        sys.stderr.write(
+            f"[reddit_tools] browser fetch status={status} for {url[:80]} (attempt {attempt}/2)\n"
+        )
+        if attempt == 1:
+            time.sleep(2.5)
+    if last_status == 429:
+        raise RateLimitedError(60)
+    if last_status:
+        raise urllib.error.HTTPError(
+            url, last_status,
+            f"reddit browser fetch failed (status={last_status})", None, None,
+        )
+    raise urllib.error.URLError(f"reddit browser transport failed for {url[:80]}")
 
 
 def _do_request(url):
-    """Make a Reddit API request with rate limit handling.
+    """Make a Reddit API request via the harness browser (sole transport).
 
-    Primary transport is the reddit-harness browser (see _fetch_via_browser);
-    urllib is the silent fallback. On 429 (urllib path): raises RateLimitedError
-    immediately if the reset would require a long wait, else absorbs short waits.
+    429 handling (inline wait / RateLimitedError) lives inside
+    _fetch_via_browser; HTTP and transport failures raise there too.
     """
     _wait_if_needed()
-    # Browser-first (bypasses Reddit's urllib 403 wall). Falls through to urllib
-    # if the harness is down or returns a non-200.
-    _body = _fetch_via_browser(url)
-    if _body is not None:
-        try:
-            return json.loads(_body)
-        except Exception:
-            sys.stderr.write(f"[reddit_tools] browser body not JSON for {url[:80]}; urllib fallback\n")
-    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
-    try:
-        resp = urllib.request.urlopen(req, timeout=20)
-        remaining = float(resp.headers.get("X-Ratelimit-Remaining", 100))
-        reset = float(resp.headers.get("X-Ratelimit-Reset", 0))
-        _write_ratelimit(remaining, reset)
-        return json.loads(resp.read())
-    except urllib.error.HTTPError as e:
-        if e.code == 429:
-            reset = float(e.headers.get("X-Ratelimit-Reset", 60))
-            _write_ratelimit(0, reset)
-            if reset > MAX_INLINE_WAIT_SECONDS:
-                raise RateLimitedError(reset)
-            print(f"Rate limited. Waiting {int(reset)+2}s...", file=sys.stderr)
-            time.sleep(int(reset) + 2)
-            # Retry once
-            resp = urllib.request.urlopen(req, timeout=20)
-            remaining = float(resp.headers.get("X-Ratelimit-Remaining", 100))
-            reset2 = float(resp.headers.get("X-Ratelimit-Reset", 0))
-            _write_ratelimit(remaining, reset2)
-            return json.loads(resp.read())
-        raise
+    return json.loads(_fetch_via_browser(url))
 
 
 def batch_fetch_info(thing_ids, user_agent=USER_AGENT):
@@ -158,41 +148,9 @@ def batch_fetch_info(thing_ids, user_agent=USER_AGENT):
         ids_str = ",".join(chunk)
         url = f"https://old.reddit.com/api/info.json?id={ids_str}"
         _wait_if_needed()
-        # Browser-first transport (Reddit 403s urllib on *.json). urllib fallback.
-        _body = _fetch_via_browser(url)
-        if _body is not None:
-            try:
-                data = json.loads(_body)
-                for child in data.get("data", {}).get("children", []):
-                    cd = child.get("data", {})
-                    name = cd.get("name")
-                    if name:
-                        results[name] = cd
-                continue
-            except Exception:
-                sys.stderr.write("[reddit_tools] browser info.json not JSON; urllib fallback\n")
-        req = urllib.request.Request(url, headers={"User-Agent": user_agent})
-        try:
-            resp = urllib.request.urlopen(req, timeout=30)
-            remaining = float(resp.headers.get("X-Ratelimit-Remaining", 100))
-            reset = float(resp.headers.get("X-Ratelimit-Reset", 0))
-            _write_ratelimit(remaining, reset)
-            data = json.loads(resp.read())
-        except urllib.error.HTTPError as e:
-            if e.code == 429:
-                reset = float(e.headers.get("X-Ratelimit-Reset", 60))
-                _write_ratelimit(0, reset)
-                if reset > MAX_INLINE_WAIT_SECONDS:
-                    raise RateLimitedError(reset)
-                print(f"Rate limited. Waiting {int(reset)+2}s...", file=sys.stderr)
-                time.sleep(int(reset) + 2)
-                resp = urllib.request.urlopen(req, timeout=30)
-                remaining = float(resp.headers.get("X-Ratelimit-Remaining", 100))
-                reset2 = float(resp.headers.get("X-Ratelimit-Reset", 0))
-                _write_ratelimit(remaining, reset2)
-                data = json.loads(resp.read())
-            else:
-                raise
+        # Browser-only transport (see _fetch_via_browser; raises on failure,
+        # including the RateLimitedError this loop's callers already handle).
+        data = json.loads(_fetch_via_browser(url))
 
         for child in data.get("data", {}).get("children", []):
             d = child.get("data", {})
@@ -620,15 +578,9 @@ def _html_postable_check(thread_url):
     try:
         url = thread_url.replace("www.reddit.com", "old.reddit.com").rstrip("/") + "/"
         _wait_if_needed()
-        # Browser-first transport (Reddit 403s urllib). urllib fallback below.
+        # Browser-only transport (see _fetch_via_browser). Raises on failure;
+        # the outer except maps that to None ("network error") as before.
         html = _fetch_via_browser(url)
-        if html is None:
-            req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
-            resp = urllib.request.urlopen(req, timeout=15)
-            remaining = float(resp.headers.get("X-Ratelimit-Remaining", 100))
-            reset = float(resp.headers.get("X-Ratelimit-Reset", 0))
-            _write_ratelimit(remaining, reset)
-            html = resp.read().decode("utf-8", errors="ignore")
         # Scope the lock check to the post header only. r/Entrepreneur (and
         # similar subs) sticky an AutoMod comment that is itself locked,
         # rendering `<span class="locked-tagline">locked comment</span>`

package/scripts/stats.py

@@ -447,64 +447,37 @@ def fetch_reddit_json(url, user_agent, max_retries=2, timeout=15):
     (success AND error) into _reddit_rate_state so the caller can pace.
     On 429, honors Retry-After (capped to 120s) and retries.
     """
-    # 2026-07-14 transport fix: Reddit started 403-blocking plain urllib on
-    # *.json (2026-05-28), which silently killed this scan (every poll came
-    # back as an HTML block page -> 'empty'/'error', zero rows patched since).
-    # Route through the logged-in harness browser first, the same transport
-    # reddit_tools._do_request has used since 2026-05-29 (the replies pass in
-    # this file already goes through it via batch_fetch_info and kept working).
-    # urllib below stays as the fallback; REDDIT_FETCH_BACKEND=urllib forces it.
-    if os.environ.get("REDDIT_FETCH_BACKEND", "harness").lower() != "urllib":
-        try:
-            from reddit_browser_fetch import browser_get_json
-            body, code = browser_get_json(url)
-            if code == 200 and body:
-                try:
-                    return ("ok", json.loads(body))
-                except Exception:
-                    pass  # non-JSON body -> fall through to urllib
-            elif code == 404:
-                return ("not_found", None)
-        except Exception:
-            pass
-    req = urllib.request.Request(url, headers={"User-Agent": user_agent})
+    # Browser-ONLY transport (2026-08-03, user decision: no urllib fallback).
+    # Reddit's TLS-fingerprint wall (2026-05-28) 403s urllib/curl on *.json
+    # unconditionally, so the old urllib fallback below could never succeed;
+    # it burned retries on guaranteed 403s and returned 'error' anyway.
+    # Transient browser failures (Reddit 503s, harness contention) get the
+    # same retry budget the urllib path had. The browser transport exposes
+    # no rate-limit headers, so 429 waits assume Reddit's standard 60s
+    # window; `user_agent`/`timeout` stay in the signature for callers but
+    # are unused (the harness browser supplies its own identity).
+    from reddit_browser_fetch import browser_get_json
+
     for attempt in range(max_retries + 1):
         try:
-            with urllib.request.urlopen(req, timeout=timeout) as resp:
-                _update_reddit_rate_state(resp.headers)
-                body = resp.read()
-                if not body:
-                    return ("empty", None)
-                try:
-                    return ("ok", json.loads(body))
-                except Exception:
-                    return ("empty", None)
-        except urllib.error.HTTPError as e:
-            _update_reddit_rate_state(e.headers)
-            if e.code == 404:
-                return ("not_found", None)
-            if e.code == 429:
-                retry_after = None
-                if e.headers:
-                    ra = e.headers.get("Retry-After")
-                    if ra:
-                        try:
-                            retry_after = int(ra)
-                        except (TypeError, ValueError):
-                            retry_after = None
-                if retry_after is None:
-                    retry_after = int(_reddit_rate_state.get("reset_in") or 60)
-                retry_after = max(1, min(retry_after, 120))
-                if attempt < max_retries:
-                    time.sleep(retry_after)
-                    continue
-                return ("rate_limited", None)
-            return ("error", None)
+            body, code = browser_get_json(url)
         except Exception:
+            body, code = None, 0
+        if code == 200 and body:
+            try:
+                return ("ok", json.loads(body))
+            except Exception:
+                return ("empty", None)
+        if code == 404:
+            return ("not_found", None)
+        if code == 429:
             if attempt < max_retries:
-                time.sleep(5 * (attempt + 1))
+                time.sleep(60)
                 continue
-            return ("error", None)
+            return ("rate_limited", None)
+        if attempt < max_retries:
+            time.sleep(5 * (attempt + 1))
+            continue
     return ("error", None)
 
 

package/scripts/twitter_browser.py

@@ -515,7 +515,11 @@ def _get_browser_and_page_raw(playwright):
                 # Otherwise reuse the first page (caller will navigate it).
                 if context.pages:
                     return browser, context.pages[0], True
-                return browser, context.new_page(), True
+                # Zero pages: create in the BACKGROUND (2026-08-03). A plain
+                # new_page() is a foreground Target.createTarget, which
+                # activates Chrome and steals macOS app focus.
+                from browser_lifecycle import background_new_page
+                return browser, background_new_page(browser, context), True
             # No contexts present (unusual on a fresh harness Chrome) — create one.
             context = browser.new_context()
             return browser, context.new_page(), True
@@ -545,7 +549,9 @@ def _get_browser_and_page_raw(playwright):
                         return browser, pg, True
                 if context.pages:
                     return browser, context.pages[0], True
-                return browser, context.new_page(), True
+                # Zero pages: background create (2026-08-03, see above).
+                from browser_lifecycle import background_new_page
+                return browser, background_new_page(browser, context), True
         except Exception as e:
             _release_browser_lock()
             print(json.dumps({