@m13v/s4l 1.7.7-rc.3 → 1.7.7-rc.5

package/mcp/dist/repo.js

@@ -71,6 +71,18 @@ export function run(cmd, args, opts = {}) {
         catch {
             /* a spawn observer must never break the run */
         }
+        if (opts.stdin != null) {
+            // Swallow async pipe errors (e.g. EPIPE when the child exits before
+            // reading) — an unhandled stream error would crash the whole process.
+            child.stdin.on("error", () => { });
+            try {
+                child.stdin.write(opts.stdin);
+                child.stdin.end();
+            }
+            catch {
+                /* a closed stdin must never break the run */
+            }
+        }
         let stdout = "";
         let stderr = "";
         // Per-stream partial-line buffers so onLine fires on whole lines only,

package/mcp/dist/version.js

@@ -195,16 +195,63 @@ async function latestFromGithubRedirect() {
         return null;
     }
 }
+// Optional GitHub token (2026-07-30): authenticated probes get 5000/h instead
+// of the anonymous 60/h-per-IP quota that silenced the staging update banner
+// on 2026-07-13 and again on 2026-07-30. Sources, in order: GITHUB_TOKEN /
+// GH_TOKEN env, then `gh auth token` when the gh CLI exists (dev/operator
+// machines; .mcpb boxes have neither and resolve to null instantly). The token
+// is only ever sent to api.github.com, always via stdin (curl -H @-) so it
+// never appears in argv/`ps`, and the `gh auth token` shell-out is noTee so it
+// never reaches the telemetry relay. Keep in lockstep with
+// scripts/snapshot.py::_github_token.
+let ghTokCache = { at: 0, tok: null };
+const GH_TOK_TTL_MS = 900_000;
+async function githubToken() {
+    const now = Date.now();
+    if (ghTokCache.at && now - ghTokCache.at < GH_TOK_TTL_MS)
+        return ghTokCache.tok;
+    let tok = process.env.GITHUB_TOKEN || process.env.GH_TOKEN || null;
+    if (!tok) {
+        for (const gh of ["/opt/homebrew/bin/gh", "/usr/local/bin/gh", "gh"]) {
+            const res = await run(gh, ["auth", "token"], { timeoutMs: 5000, noTee: true });
+            if (res.code === -1)
+                continue; // not spawnable at this path; try the next
+            const cand = (res.stdout || "").trim();
+            if (res.code === 0 && cand)
+                tok = cand;
+            break;
+        }
+    }
+    ghTokCache = { at: now, tok };
+    return tok;
+}
 // Conditional-request state lives in the SHARED cache file (latest-release.json)
 // so the ETag survives process boundaries: short-lived MCP respawns used to pay
 // a full 200 per process; now every probe sends If-None-Match and gets a free
-// 304 between releases.
+// 304 between releases. Probes authenticate when a GitHub token is available;
+// a 401 (revoked/expired token) retries anonymously so a bad token is never
+// worse than no token.
 async function curlConditional(url, etag) {
+    const tok = await githubToken();
+    const first = await curlOnce(url, etag, tok);
+    if (first.status === 401 && tok) {
+        ghTokCache = { at: Date.now(), tok: null }; // drop the dead token
+        return curlOnce(url, etag, null);
+    }
+    return first;
+}
+async function curlOnce(url, etag, token) {
     const args = ["-sS", "-m", "10", "-H", "Accept: application/vnd.github+json"];
+    if (token)
+        args.push("-H", "@-"); // Authorization arrives via stdin, never argv
     if (etag)
         args.push("-H", `If-None-Match: ${etag}`);
     args.push("-w", "\n__CURL_STATUS__:%{http_code}\n__CURL_ETAG__:%header{etag}", url);
-    const res = await run("curl", args, { timeoutMs: 12000, noTee: true });
+    const res = await run("curl", args, {
+        timeoutMs: 12000,
+        noTee: true,
+        stdin: token ? `Authorization: Bearer ${token}` : undefined,
+    });
     let status = 0;
     let newEtag = null;
     const body = [];

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.7-rc.3",
-  "installedAt": "2026-07-30T22:30:41.307Z"
+  "version": "1.7.7-rc.5",
+  "installedAt": "2026-07-31T22:56:07.561Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.7-rc.3",
+  "version": "1.7.7-rc.5",
   "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_browser_foreground.py

@@ -156,9 +156,14 @@ class _Worker(threading.Thread):
         # the foreground, hide that specific Chrome process by pid, then force
         # focus back to the app the user was in. Screenshots/clicks are
         # unaffected (CDP is offscreen-raster + synthetic input; the occlusion
-        # flags keep hidden tabs painting). Escape hatch: S4L_NO_HARNESS_HIDE.
+        # flags keep hidden tabs painting).
+        # DEFAULT OFF (user decision 2026-07-30): only the telemetry above runs
+        # unless S4L_HARNESS_HIDE=1 opts in. S4L_NO_HARNESS_HIDE force-disables
+        # even when the opt-in is set.
         if os.environ.get("S4L_NO_HARNESS_HIDE"):
             return
+        if os.environ.get("S4L_HARNESS_HIDE") != "1":
+            return
         pos = details.get("window_position") or ""
         try:
             offscreen = any(int(float(v)) < 0 for v in pos.split(",")[:2])

package/mcp/menubar/s4l_card.py

@@ -464,12 +464,12 @@ def _compact_arm(variant):
 
 
 def _reply_heading_suffix(d):
-    """Concise 'project/lane · viral N · t v4' readout appended straight onto the
-    'Reply (editable):' heading (2026-07-07), so the two facts a reviewer
-    checks first don't require opening the details eye. Pulled from the same
+    """Concise 'project · viral N · t v4' readout appended straight onto the
+    'Reply (editable):' heading (2026-07-07), so the facts a reviewer checks
+    first don't require opening the details eye. Pulled from the same
     fields _details_lines used to render as 'Project:'/'Lane:'/'Virality
-    score:' rows; those three are omitted from the popover now to avoid
-    showing the same numbers twice. Empty string when neither is known."""
+    score:' rows; those are omitted from the popover now to avoid showing
+    the same numbers twice. Empty string when neither is known."""
     d = d or {}
     project = (d.get("project") or "").strip()
     lane = ((d.get("experiments") or {}).get("lane") or "").strip()
@@ -480,20 +480,11 @@ def _reply_heading_suffix(d):
         # approve_() blocks posting on these and the reviewer should know why
         # before clicking rather than after.
         bits.append("⚠ SANDBOX — not postable")
-    # Project and lane are independent concepts most of the time (project
-    # "fazm" drafted under lane "personal_brand"), but the operator's own
-    # PersonalBrand project IS the personal_brand lane, so project=="PersonalBrand"
-    # + lane=="personal_brand" is the SAME fact twice, not two facts — compare
-    # with punctuation/case stripped so "PersonalBrand" vs "personal_brand"
-    # collapses to one token instead of "PersonalBrand/personal_brand".
-    same = project and lane and re.sub(r"[^a-z0-9]", "", project.lower()) == re.sub(
-        r"[^a-z0-9]", "", lane.lower()
-    )
-    if same:
-        bits.append(project)
-    elif project and lane:
-        bits.append(f"{project}/{lane}")
-    elif project:
+    # Heading shows the project/lane name only, never a combined
+    # "project/lane" string (2026-07-31, user call: the "/promotion" suffix
+    # on cards was confusing). Lane is still stamped on the candidate and
+    # readable in the details popover; it's just not concatenated here.
+    if project:
         bits.append(project)
     elif lane:
         bits.append(lane)

package/mcp/package.json

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

@@ -1,11 +1,21 @@
 #!/usr/bin/env python3
-"""Close every CDP "page" tab in harness Chrome except one.
+"""Close every CDP "page" tab in harness Chrome except one, and keep that one
+tab REAL (http/https).
 
-Called from skill/lib/twitter-backend.sh::ensure_twitter_browser_for_backend
-and skill/engage-twitter.sh's inline harness branch as part of pre-flight.
-Safe to call any time: exits 0 silently when harness Chrome is down. Workers
-and iframe targets are left alone; they auto-clean when their parent page
-closes.
+Called from skill/lib/harness-common.sh::hc_cleanup_tabs (all three platform
+backends) as part of pre-flight. Safe to call any time: exits 0 silently when
+harness Chrome is down. Workers and iframe targets are left alone; they
+auto-clean when their parent page closes.
+
+Revive (2026-07-31): when BH_REVIVE_URL is set to an http(s) url, a Chrome
+whose only tab is about:blank gets that tab navigated to the revive url, and
+a completely tabless Chrome (--no-startup-window launch) gets ONE background
+tab created there. This matters because the harness daemon's is_real_page()
+refuses about:/chrome: tabs — a blank-only browser used to trap it in a
+"stale session -> foreground createTarget(about:blank) -> still not real"
+loop, one macOS focus steal per iteration (30/day on reddit-harness).
+Both revive paths need websocket-client (present in the owned runtime venv,
+S4L_PYTHON); without it the script degrades to close-only, as before.
 
 The standalone-script form (vs an inline heredoc) is required because bash
 3.2 on macOS cannot parse a nested heredoc inside a function body inside a
@@ -24,6 +34,56 @@ import urllib.request
 # its own harness Chrome on 9556. Default 9555 keeps Twitter callers unchanged.
 CDP_PORT = int(os.environ.get("BH_CLEANUP_PORT", "9555"))
 CDP_URL = f"http://127.0.0.1:{CDP_PORT}"
+REVIVE_URL = os.environ.get("BH_REVIVE_URL", "")
+
+
+def _is_real(t) -> bool:
+    return (t.get("url") or "").startswith(("http://", "https://"))
+
+
+def _ws_call(ws_url: str, method: str, timeout: float = 8.0, **params):
+    # suppress_origin: Chrome 111+ rejects ws clients whose Origin header is
+    # not in --remote-allow-origins (same pattern as cdp_ready_check.py).
+    import websocket  # websocket-client; ImportError handled by callers
+
+    ws = websocket.create_connection(ws_url, timeout=timeout, suppress_origin=True)
+    try:
+        ws.send(json.dumps({"id": 1, "method": method, "params": params}))
+        import time
+
+        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()
+
+
+def _revive(keep) -> None:
+    """Ensure one REAL tab exists: navigate a lone non-real tab (keep) to
+    REVIVE_URL, or create a background tab there when keep is None (tabless
+    Chrome). Best-effort; cleanup's exit code never depends on it."""
+    if not REVIVE_URL.startswith(("http://", "https://")):
+        return
+    try:
+        if keep is None:
+            # background=True: a foreground Target.createTarget raises the
+            # Chrome window and steals macOS app focus; revive must be silent.
+            info = json.loads(
+                urllib.request.urlopen(f"{CDP_URL}/json/version", timeout=2).read()
+            )
+            _ws_call(
+                info["webSocketDebuggerUrl"], "Target.createTarget",
+                url=REVIVE_URL, background=True,
+            )
+            print(f"[cleanup_harness_tabs] created background tab on {REVIVE_URL}")
+        elif not _is_real(keep) and keep.get("webSocketDebuggerUrl"):
+            _ws_call(keep["webSocketDebuggerUrl"], "Page.navigate", url=REVIVE_URL)
+            print(f"[cleanup_harness_tabs] revived blank tab -> {REVIVE_URL}")
+    except Exception as e:
+        print(f"[cleanup_harness_tabs] revive skipped ({type(e).__name__}: {e})")
 
 
 def main() -> int:
@@ -33,8 +93,13 @@ def main() -> int:
     except Exception:
         return 0
     pages = [t for t in tabs if t.get("type") == "page"]
-    if len(pages) <= 1:
-        print(f"[cleanup_harness_tabs] {len(pages)} page tab(s), no cleanup needed")
+    if not pages:
+        print("[cleanup_harness_tabs] 0 page tab(s)")
+        _revive(None)
+        return 0
+    if len(pages) == 1:
+        print("[cleanup_harness_tabs] 1 page tab(s), no cleanup needed")
+        _revive(pages[0])
         return 0
     # Keep a REAL (http/https) tab when one exists, not blindly pages[0]. The
     # /json order is roughly most-recently-active first, so a freshly-spawned
@@ -43,9 +108,6 @@ def main() -> int:
     # daemon's tab forces it to re-attach and re-spawn another about:blank, which
     # is exactly the orphan-tab churn this script is meant to clean up. Falling
     # back to pages[0] preserves the prior behavior when every tab is blank.
-    def _is_real(t):
-        return (t.get("url") or "").startswith(("http://", "https://"))
-
     keep = next((t for t in pages if _is_real(t)), pages[0])
     closed = 0
     for t in pages:
@@ -61,6 +123,7 @@ def main() -> int:
             pass
     kept_kind = "1 real" if _is_real(keep) else "1"
     print(f"[cleanup_harness_tabs] closed {closed}/{len(pages) - 1} extra page tabs (kept {kept_kind})")
+    _revive(keep)
     return 0
 
 

package/scripts/s4l_box_update.sh

@@ -73,11 +73,36 @@ channel = ch if ch in ("stable", "staging") else "stable"
 REPO = "m13v/s4l"
 TAG_DL = "https://github.com/%s/releases/download/%s/social-autoposter.mcpb"
 
-def curl(url):
+# Optional GitHub token (2026-07-30): authenticated requests get 5000/h vs the
+# anonymous 60/h-per-IP quota (which, exhausted, makes this resolver fail
+# closed). Sources: GITHUB_TOKEN / GH_TOKEN env, then `gh auth token` when the
+# gh CLI exists (boxes have neither; resolves to None instantly). Sent via
+# stdin (-H @-), never argv. Keep in lockstep with snapshot.py::_github_token.
+def gh_token():
+    tok = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN") or None
+    if not tok:
+        for gh in ("/opt/homebrew/bin/gh", "/usr/local/bin/gh", "gh"):
+            try:
+                r = subprocess.run([gh, "auth", "token"],
+                                   capture_output=True, text=True, timeout=5)
+                cand = (r.stdout or "").strip()
+                if r.returncode == 0 and cand:
+                    tok = cand
+                break
+            except FileNotFoundError:
+                continue
+            except Exception:
+                break
+    return tok
+
+def curl(url, token=None):
     try:
-        r = subprocess.run(["/usr/bin/curl", "-fsSL", "-m", "15",
-                            "-H", "Accept: application/vnd.github+json", url],
-                           capture_output=True, text=True, timeout=20)
+        args = ["/usr/bin/curl", "-fsSL", "-m", "15",
+                "-H", "Accept: application/vnd.github+json"]
+        if token:
+            args += ["-H", "@-"]
+        r = subprocess.run(args + [url], capture_output=True, text=True, timeout=20,
+                           input=("Authorization: Bearer %s" % token) if token else None)
         return r.stdout if r.returncode == 0 else ""
     except Exception:
         return ""
@@ -93,8 +118,13 @@ def ver_key(v):
     m = re.findall(r"\d+", pre)
     return (nums[0], nums[1], nums[2], 0, int(m[-1]) if m else 0)
 
+_tok = gh_token()
+_url = "https://api.github.com/repos/%s/releases?per_page=30" % REPO
+_raw = curl(_url, _tok)
+if not _raw and _tok:
+    _raw = curl(_url)  # bad token must never be worse than anonymous
 try:
-    rels = json.loads(curl("https://api.github.com/repos/%s/releases?per_page=30" % REPO) or "[]")
+    rels = json.loads(_raw or "[]")
 except Exception:
     rels = []
 best = None

package/scripts/snapshot.py

@@ -482,18 +482,69 @@ def _latest_from_github_redirect():
         return None
 
 
+# ---- optional GitHub token (2026-07-30) -----------------------------------
+# Authenticated probes get a 5000/h quota instead of the anonymous 60/h-per-IP
+# quota that silenced the staging update banner on 2026-07-13 and again on
+# 2026-07-30 (rate-limited staging probe degraded to the prerelease-blind
+# releases/latest redirect, so a staging box resolved stable and never saw the
+# rc). Sources, in order: GITHUB_TOKEN / GH_TOKEN env, then `gh auth token`
+# when the gh CLI exists (dev/operator machines; .mcpb boxes have neither and
+# resolve to None instantly). The token is only ever sent to api.github.com,
+# always via stdin (-H @-) so it never appears in `ps` or logs. Keep in
+# lockstep with mcp/src/version.ts::githubToken.
+_gh_tok_cache = {"at": 0.0, "tok": None}
+_GH_TOK_TTL = 900.0
+
+
+def _github_token():
+    now = time.time()
+    if _gh_tok_cache["at"] and now - _gh_tok_cache["at"] < _GH_TOK_TTL:
+        return _gh_tok_cache["tok"]
+    tok = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN") or None
+    if not tok:
+        for gh in ("/opt/homebrew/bin/gh", "/usr/local/bin/gh", "gh"):
+            try:
+                res = subprocess.run([gh, "auth", "token"],
+                                     capture_output=True, text=True, timeout=5)
+                cand = (res.stdout or "").strip()
+                if res.returncode == 0 and cand:
+                    tok = cand
+                break
+            except FileNotFoundError:
+                continue
+            except Exception:
+                break
+    _gh_tok_cache.update(at=now, tok=tok)
+    return tok
+
+
 # Conditional-request state lives in the SHARED cache file (latest-release.json)
 # so the ETag survives process boundaries: short-lived shell-outs used to pay a
 # full 200 per process; now every probe sends If-None-Match and gets a free 304
 # between releases.
 def _curl_conditional(url, etag):
-    """GET url with optional If-None-Match. Returns (status, new_etag, body)."""
+    """GET url with optional If-None-Match, authenticated when a GitHub token
+    is available. Returns (status, new_etag, body). On 401 with a token
+    (revoked/expired) retries anonymously so a bad token is never worse than
+    no token."""
+    tok = _github_token()
+    status, new_etag, body = _curl_once(url, etag, tok)
+    if status == 401 and tok:
+        _gh_tok_cache.update(tok=None)  # drop the dead token for this process
+        status, new_etag, body = _curl_once(url, etag, None)
+    return status, new_etag, body
+
+
+def _curl_once(url, etag, token):
     args = ["/usr/bin/curl", "-sS", "-m", "10",
             "-H", "Accept: application/vnd.github+json"]
+    if token:
+        args += ["-H", "@-"]  # Authorization arrives via stdin, never argv
     if etag:
         args += ["-H", "If-None-Match: %s" % etag]
     args += ["-w", "\n__CURL_STATUS__:%{http_code}\n__CURL_ETAG__:%header{etag}", url]
-    res = subprocess.run(args, capture_output=True, text=True, timeout=12)
+    res = subprocess.run(args, capture_output=True, text=True, timeout=12,
+                         input=("Authorization: Bearer %s" % token) if token else None)
     status, new_etag, body = 0, None, []
     for line in (res.stdout or "").splitlines():
         if line.startswith("__CURL_STATUS__:"):

package/scripts/twitter_browser.py

@@ -14,6 +14,9 @@ Usage:
     # Scan DM inbox for unread conversations
     python3 twitter_browser.py unread-dms
 
+    # Same scan, plus the Message Requests tab (rows tagged is_request=true)
+    python3 twitter_browser.py unread-dms --include-requests
+
     # Read messages from a DM conversation
     python3 twitter_browser.py read-conversation "https://x.com/i/chat/123-456"
 
@@ -1495,15 +1498,24 @@ def reply_to_tweet(tweet_url, text, apply_campaigns=True):
                 browser.close()
 
 
-def unread_dms():
+def unread_dms(include_requests=False):
     """Scan Twitter/X DM inbox for conversations.
 
     Navigates to /i/chat, handles the encryption passcode if needed,
     and extracts all visible conversations with their author, preview text,
     timestamp, and conversation URL.
 
+    include_requests=True additionally scans the Message Requests tab
+    (/i/chat/requests, inbound DMs from people we don't follow) with the
+    exact same scrape/scroll code and appends those rows to the result.
+    Every row carries "is_request" (true only for requests-tab rows) so the
+    pipeline can apply a relevance gate before replying. A requests-tab
+    failure degrades to primary-only results (stderr note) rather than
+    failing the whole scan.
+
     Returns: [{"author": "...", "handle": "...", "preview": "...", "time": "...",
-               "thread_url": "...", "is_from_us": bool, "has_unread": bool}, ...]
+               "thread_url": "...", "is_from_us": bool, "has_unread": bool,
+               "is_request": bool}, ...]
 
     `has_unread` is the signal callers should filter on. It is derived from the
     sidebar's visual unread state (aria-label "unread", bold font weight on the
@@ -1563,7 +1575,11 @@ def unread_dms():
                     if (!link) continue;
 
                     const threadUrl = link.href;
-                    if (!threadUrl.match(/\\/i\\/chat\\/[\\d-g]/)) continue;
+                    // Accept both /i/chat/<ids> (primary inbox) and
+                    // /i/chat/requests/<ids> (Message Requests tab). The bare
+                    // "Message requests" row link (/i/chat/requests, no ids)
+                    // still fails the match and stays excluded.
+                    if (!threadUrl.match(/\\/i\\/chat\\/(requests\\/)?[\\d-g]/)) continue;
 
                     let handle = '';
                     const avatarLink = item.querySelector('a[href^="https://x.com/"]');
@@ -1678,27 +1694,86 @@ def unread_dms():
                 return 0;
             }"""
 
-            seen = {}
-            stuck_iters = 0
-            max_iters = int(os.environ.get("TWITTER_UNREAD_SCROLL_MAX_ITERS", "60"))
-            max_no_growth = int(os.environ.get("TWITTER_UNREAD_SCROLL_NO_GROWTH", "5"))
-            for _ in range(max_iters):
-                batch = page.evaluate(scrape_js)
-                grew = False
-                for c in batch:
-                    if c["thread_url"] not in seen:
-                        seen[c["thread_url"]] = c
-                        grew = True
-                if not grew:
-                    stuck_iters += 1
-                else:
-                    stuck_iters = 0
-                if stuck_iters >= max_no_growth:
-                    break
-                page.evaluate(scroll_js)
-                page.wait_for_timeout(600)
-
-            unique = list(seen.values())
+            def _scan_sidebar(is_request):
+                # Shared scrape+scroll loop for both the primary inbox and
+                # the Message Requests tab (same virtualized sidebar DOM).
+                seen = {}
+                stuck_iters = 0
+                max_iters = int(os.environ.get("TWITTER_UNREAD_SCROLL_MAX_ITERS", "60"))
+                max_no_growth = int(os.environ.get("TWITTER_UNREAD_SCROLL_NO_GROWTH", "5"))
+                for _ in range(max_iters):
+                    batch = page.evaluate(scrape_js)
+                    grew = False
+                    for c in batch:
+                        if c["thread_url"] not in seen:
+                            c["is_request"] = is_request
+                            seen[c["thread_url"]] = c
+                            grew = True
+                    if not grew:
+                        stuck_iters += 1
+                    else:
+                        stuck_iters = 0
+                    if stuck_iters >= max_no_growth:
+                        break
+                    page.evaluate(scroll_js)
+                    page.wait_for_timeout(600)
+                return list(seen.values())
+
+            unique = _scan_sidebar(False)
+
+            # Message Requests pass: same DOM, same scrape/scroll code, just
+            # a different page. These are inbound DMs from people we don't
+            # follow; they never appear in the /i/chat sidebar (the
+            # "Message requests" row itself is dropped by the thread-URL
+            # regex above), so without this pass they are invisible to the
+            # whole DM pipeline.
+            if include_requests:
+                try:
+                    # A concurrent pipeline sharing this harness tab can yank
+                    # navigation between our goto and the scrape (landing on
+                    # e.g. a search page), which would silently scrape 0
+                    # request rows. Verify the URL stuck; re-goto up to 2x.
+                    landed = False
+                    for _nav_try in range(3):
+                        page.goto(
+                            "https://x.com/i/chat/requests",
+                            wait_until="domcontentloaded",
+                        )
+                        page.wait_for_timeout(5000)
+                        if "chat/requests" in page.url:
+                            landed = True
+                            break
+                    unreachable, reason = _is_x_unreachable(page)
+                    if unreachable:
+                        print(
+                            f"[unread_dms] requests tab unreachable ({reason}); "
+                            "returning primary-only results",
+                            file=sys.stderr,
+                        )
+                    elif not landed:
+                        print(
+                            f"[unread_dms] requests tab navigation hijacked "
+                            f"(landed on {page.url}); returning primary-only "
+                            "results",
+                            file=sys.stderr,
+                        )
+                    else:
+                        primary_urls = {c["thread_url"] for c in unique}
+                        n_req = 0
+                        for c in _scan_sidebar(True):
+                            if c["thread_url"] not in primary_urls:
+                                unique.append(c)
+                                n_req += 1
+                        print(
+                            f"[unread_dms] requests tab scanned: {n_req} rows",
+                            file=sys.stderr,
+                        )
+                except Exception as e:
+                    print(
+                        f"[unread_dms] requests scan failed ({e}); "
+                        "returning primary-only results",
+                        file=sys.stderr,
+                    )
 
             # If the inbox API was throttled hard AND we got nothing back,
             # treat this as rate-limited so the caller can back off instead
@@ -1754,6 +1829,60 @@ def read_conversation(thread_url, max_messages=20):
                 const main = document.querySelector('main');
                 if (!main) return {partner_name: '', partner_handle: '', messages: [], total_found: 0};
 
+                // 2026-07-30: X shipped a redesigned chat thread DOM. The
+                // message list is now [data-testid="dm-message-list"] with one
+                // [data-testid="message-<uuid>"] node per bubble and the text
+                // inside [data-testid="message-text-<uuid>"]; the old
+                // li/[role=listitem] structure is gone (this silently zeroed
+                // every read from ~07-28). Direction comes from the bubble
+                // row's computed justify-content: flex-end = ours,
+                // flex-start = theirs (verified against a mixed
+                // conversation). The legacy extraction below stays as the
+                // fallback for any account still on the old DOM.
+                const v2list = main.querySelector('[data-testid="dm-message-list"]');
+                if (v2list) {
+                    const uEl = main.querySelector('[data-testid="dm-conversation-username"]');
+                    if (uEl) partnerName = uEl.textContent.trim();
+                    const handleEls2 = main.querySelectorAll('div, span');
+                    for (const el of handleEls2) {
+                        const t = el.textContent.trim();
+                        if (t.startsWith('@') && t.length > 2 && t.length < 50 &&
+                            !t.includes(' ') && t.substring(1) !== ourHandle) {
+                            partnerHandle = t.substring(1);
+                            break;
+                        }
+                    }
+                    const messages = [];
+                    for (const item of v2list.querySelectorAll('[data-testid^="message-"]')) {
+                        const tid = item.getAttribute('data-testid') || '';
+                        if (tid.startsWith('message-text-')) continue;
+                        const textEl = item.querySelector('[data-testid^="message-text-"]');
+                        let content = ((textEl ? textEl.textContent : item.textContent) || '');
+                        const fullText = item.textContent || '';
+                        const timeMatch = fullText.match(/(\\d{1,2}:\\d{2}\\s*[AP]M)/);
+                        const time = timeMatch ? timeMatch[1] : '';
+                        content = content
+                            .replace(/(\\d{1,2}:\\d{2}\\s*[AP]M)/g, '')
+                            .replace(/(Seen|Delivered|Sent)\\s*$/, '')
+                            .trim();
+                        if (!content) continue;
+                        const isFromUs =
+                            window.getComputedStyle(item).justifyContent === 'flex-end';
+                        messages.push({
+                            sender: isFromUs ? ourHandle : (partnerHandle || partnerName),
+                            content: content,
+                            time: time,
+                            is_from_us: isFromUs,
+                        });
+                    }
+                    return {
+                        partner_name: partnerName,
+                        partner_handle: partnerHandle,
+                        messages: messages.slice(-maxMessages),
+                        total_found: messages.length,
+                    };
+                }
+
                 // Find the conversation panel (the section containing the
                 // message textbox), NOT the sidebar conversation list.
                 // The textbox has aria-label like "Unencrypted message".
@@ -2069,6 +2198,22 @@ def send_dm(thread_url, message, dm_id=None, apply_campaigns=True):
                     "landed_url": page.url,
                 }
 
+            # Message-request threads (from x.com/i/chat/requests) hide the
+            # compose box behind an Accept banner until the request is
+            # accepted. Accepting moves the thread to the primary inbox and
+            # does not notify the sender; the reply we're about to send is
+            # the visible action. No-op on normal threads (button absent).
+            try:
+                _accept = page.get_by_role(
+                    "button", name=re.compile(r"^Accept\b", re.I)
+                )
+                if _accept.count() > 0 and _accept.first.is_visible():
+                    _accept.first.click()
+                    page.wait_for_timeout(2000)
+                    print("[send_dm] accepted message request", file=sys.stderr)
+            except Exception:
+                pass
+
             # Find the message input box
             msg_box = None
             for label in ["Unencrypted message", "Start a new message"]:
@@ -2085,6 +2230,17 @@ def send_dm(thread_url, message, dm_id=None, apply_campaigns=True):
                         'div[role="textbox"][contenteditable="true"]'
                     ).last
                     msg_box.wait_for(state="visible", timeout=3000)
+                except Exception:
+                    msg_box = None
+
+            # 2026-07-30 chat redesign: the composer is now a plain
+            # <textarea data-testid="dm-composer-textarea"> (placeholder
+            # "Unencrypted message"), no contenteditable div and no
+            # role/aria-label attributes.
+            if not msg_box:
+                try:
+                    msg_box = page.locator('[data-testid="dm-composer-textarea"]')
+                    msg_box.wait_for(state="visible", timeout=3000)
                 except Exception:
                     return {"ok": False, "error": "message_box_not_found"}
 
@@ -2110,6 +2266,21 @@ def send_dm(thread_url, message, dm_id=None, apply_campaigns=True):
             if verified and dm_id is not None:
                 _log_twitter_dm_outbound(dm_id, message, minted_codes=minted_link_codes)
 
+            # A verified send on a message-request thread accepts the
+            # request, which moves the conversation to the primary inbox
+            # where the /i/chat/requests/<ids> URL no longer resolves
+            # (X bounces it to the requests list). Canonicalize the stored
+            # chat_url so follow-up sends navigate correctly.
+            if verified and dm_id is not None and "/i/chat/requests/" in thread_url:
+                try:
+                    import http_api
+                    canonical = thread_url.replace("/i/chat/requests/", "/i/chat/")
+                    http_api.api_patch(f"/api/v1/dms/{dm_id}", {"chat_url": canonical})
+                    print(f"[send_dm] request accepted; canonicalized chat_url -> {canonical}",
+                          file=sys.stderr)
+                except Exception as e:
+                    print(f"[send_dm] chat_url canonicalize failed: {e}", file=sys.stderr)
+
             return {
                 "ok": verified,
                 "thread_url": page.url,
@@ -2744,7 +2915,11 @@ def main():
         print(json.dumps(result, indent=2))
 
     elif cmd == "unread-dms":
-        result = unread_dms()
+        # --include-requests: also scan x.com/i/chat/requests (message
+        # requests from people we don't follow); those rows carry
+        # is_request=true.
+        _inc_req = "--include-requests" in sys.argv[2:]
+        result = unread_dms(include_requests=_inc_req)
         print(json.dumps(result, indent=2))
 
     elif cmd == "read-conversation":

package/skill/engage-dm-replies.sh

@@ -551,12 +551,15 @@ if [ -z "$PLATFORM" ] || [ "$PLATFORM" = "twitter" ] || [ "$PLATFORM" = "x" ]; t
     IFS= read -r -d '' PHASE_C_BLOCK <<'PHASE_C_EOF' || true
 ## PHASE C: Scan X/Twitter DMs for new messages
 
-1. Get ALL Twitter DM conversations visible in the sidebar (the script returns the full list, not only unread) and write them to /tmp/twitter_threads.json:
+1. Get ALL Twitter DM conversations visible in the sidebar (the script returns the full list, not only unread), INCLUDING the Message Requests tab (x.com/i/chat/requests), and write them to /tmp/twitter_threads.json:
    ```bash
-   python3 scripts/twitter_browser.py unread-dms > /tmp/twitter_threads.json
+   python3 scripts/twitter_browser.py unread-dms --include-requests > /tmp/twitter_threads.json
    ```
    This handles the encrypted DM passcode automatically (loaded from .env TWITTER_DM_PASSCODE).
-   Returns JSON array with: author, handle, preview, time, thread_url, is_from_us, has_unread.
+   Returns JSON array with: author, handle, preview, time, thread_url, is_from_us, has_unread, is_request.
+   Rows with `is_request: true` came from the Message Requests tab: cold inbound DMs from people we don't follow who messaged us first. They flow through the exact same steps below (backfill, filter, read, ensure-dm, log-inbound, mark-inspected); the only difference is a relevance gate at reply time (step 3f). If the script's stderr shows "requests tab unreachable" or "navigation hijacked", proceed with the primary-only rows it returned; do not re-run the scan.
+   **URL form for request threads: keep `/i/chat/requests/<ids>` EXACTLY as scanned.** Pass it verbatim to read-conversation, ensure-dm, and send-dm. Do NOT strip the `/requests/` segment yourself: the canonical `/i/chat/<ids>` form does not resolve until the request is accepted (X bounces it to the requests list), so a hand-normalized chat_url breaks every later send. send-dm canonicalizes the stored chat_url automatically after the accepting reply goes through.
+   **Request backlog cap: inspect at most the 10 NEWEST `is_request` threads per run** (they are already newest-first in the scan). A burst of accepts/replies across a weeks-old backlog in one cycle is a behavioral-fingerprint risk; the rest of the backlog drains 10 per cycle on subsequent runs. The cap applies only to `is_request` rows; normal threads are unaffected.
 
 1a. Backfill chat URLs for any existing X DM row still missing one. Cheap, idempotent, fills buttons for historical rows whose chat is still in the sidebar:
    ```bash
@@ -593,6 +596,13 @@ if [ -z "$PLATFORM" ] || [ "$PLATFORM" = "twitter" ] || [ "$PLATFORM" = "x" ]; t
       python3 scripts/dm_conversation.py mark-inspected --dm-id DM_ID
       ```
       Skipping this on a "nothing new" thread is the bug that makes us re-open the same cold conversation every cycle. Always run it. The next filter-inbox will skip the thread for 24h unless a fresh inbound or outbound is logged in the meantime.
+   f. **Message requests only (`is_request: true` on the sidebar row): relevance gate before any reply.** The requests tab mixes real leads with spam, so decide per thread after reading it:
+      - RELEVANT (mentions our projects/products or their problem space, responding to our public posts, genuine question, plausible customer or partner): treat it as a normal conversation. It will surface in Phase D via the pending rail and gets a reply there. Sending the reply is what accepts the request; `send-dm` clicks the Accept button itself, and accepting does not notify them, so the reply is the first visible action.
+      - SPAM or IRRELEVANT (crypto/engagement-farm blasts, template "collab?" mass marketing, bots, adult content, pure solicitation with zero connection to us): do NOT reply and do NOT accept. Still complete steps c-d so the message is on record, THEN close the conversation so it never re-enters the queue:
+        ```bash
+        python3 scripts/dm_conversation.py set-status --dm-id DM_ID --status closed
+        ```
+        Run set-status closed AFTER log-inbound (log-inbound flips the row to needs_reply; closed must win). Never delete or block request threads from this pipeline.
 PHASE_C_EOF
 fi
 

package/skill/lib/harness-common.sh

@@ -33,7 +33,12 @@
 #   HC_PROFILE_DIR   - Chrome profile dir; also the exact-dir pgrep reap match
 #   HC_DEFAULT_URL   - http://127.0.0.1:<port>; ownership test vs external/BYO
 #   HC_CDP_URL       - actual CDP url (backend passes its <PLATFORM>_CDP_URL)
-#   HC_LAUNCH_URL    - first-tab url (default about:blank)
+#   HC_LAUNCH_URL    - first-tab url (default derived per HC_PLATFORM via
+#                      _hc_default_launch_url; BH_LAUNCH_URL env overrides).
+#                      MUST be a real http(s) page: the harness daemon's
+#                      is_real_page() refuses about:/chrome: tabs, and a
+#                      blank-only Chrome used to trap it in a foreground
+#                      createTarget loop = focus steals (2026-07-31)
 #   HC_WINDOW_POS    - macOS offscreen window position (x,y)
 #   HC_WINDOW_SIZE   - macOS window size (w,h)
 #   HC_EXTRA_FLAGS   - extra platform Chrome flags, ONE STRING, split on
@@ -203,6 +208,22 @@ hc_record_health() {
         > "$_f" 2>/dev/null || true
 }
 
+_hc_default_launch_url() {
+    # Per-platform first-tab / revive url ($1 = platform, default HC_PLATFORM).
+    # ONE map for every backend — the per-backend HC_LAUNCH_URL copies drifted
+    # (twitter had x.com, reddit/linkedin had about:blank, which armed the
+    # daemon's blank-tab focus-steal loop; see cleanup_harness_tabs.py).
+    # robots.txt = static real page, no SPA to crash while parked, same-domain
+    # so tab-reuse preferences still match. Twitter keeps x.com: its post-
+    # launch session-restore hook has always run against the full page.
+    case "${1:-${HC_PLATFORM:-}}" in
+        twitter)  echo "https://x.com" ;;
+        reddit)   echo "https://www.reddit.com/robots.txt" ;;
+        linkedin) echo "https://www.linkedin.com/robots.txt" ;;
+        *)        echo "about:blank" ;;
+    esac
+}
+
 hc_cleanup_tabs() {
     # Close every CDP "page" tab except one. $1 = port, $2 = log label.
     # Delegated to a standalone Python script because bash 3.2 (what launchd
@@ -221,7 +242,15 @@ hc_cleanup_tabs() {
             return 0
         fi
     fi
-    BH_CLEANUP_PORT="$_port" python3 "$_BH_REPO_DIR/scripts/cleanup_harness_tabs.py" 2>/dev/null || true
+    # BH_REVIVE_URL lets the script heal a blank-only / tabless Chrome by
+    # (re)establishing one real tab in the BACKGROUND — without it the harness
+    # daemon can never re-attach cleanly (is_real_page rejects about:blank).
+    # Platform derived from the label ("reddit-harness" -> reddit). S4L_PYTHON
+    # (owned runtime venv) has websocket-client; bare python3 degrades to
+    # close-only, same as before.
+    BH_CLEANUP_PORT="$_port" \
+    BH_REVIVE_URL="$(_hc_default_launch_url "${_label%-harness}")" \
+        "${S4L_PYTHON:-python3}" "$_BH_REPO_DIR/scripts/cleanup_harness_tabs.py" 2>/dev/null || true
 }
 
 # Shared interpreter for the reserved skip code 78 (2026-07-15). Every
@@ -418,7 +447,7 @@ hc_ensure_browser() {
         # pipeline op mints its tab via the background Target.createTarget
         # path) a positional URL argument would force a window and defeat the
         # flag — drop the launch URL in that mode.
-        local _launch_url="${HC_LAUNCH_URL:-about:blank}"
+        local _launch_url="${HC_LAUNCH_URL:-${BH_LAUNCH_URL:-$(_hc_default_launch_url)}}"
         case " ${HC_EXTRA_FLAGS:-} " in
             *" --no-startup-window "*) _launch_url="" ;;
         esac

package/skill/lib/linkedin-backend.sh

@@ -297,7 +297,6 @@ ensure_linkedin_browser_for_backend() {
     HC_PROFILE_DIR="$HOME/.claude/browser-profiles/browser-harness-linkedin" \
     HC_DEFAULT_URL="$_BH_LINKEDIN_DEFAULT_URL" \
     HC_CDP_URL="${LINKEDIN_CDP_URL:-$_BH_LINKEDIN_DEFAULT_URL}" \
-    HC_LAUNCH_URL="about:blank" \
     HC_WINDOW_POS="${BH_LINKEDIN_WINDOW_POS:-3814,-1050}" \
     HC_WINDOW_SIZE="${BH_LINKEDIN_WINDOW_SIZE:-1024,1013}" \
     HC_EXTRA_FLAGS="--disable-renderer-backgrounding --disable-background-timer-throttling" \

package/skill/lib/reddit-backend.sh

@@ -149,7 +149,6 @@ ensure_reddit_browser_for_backend() {
     HC_PROFILE_DIR="$HOME/.claude/browser-profiles/reddit-harness" \
     HC_DEFAULT_URL="$_BH_REDDIT_DEFAULT_URL" \
     HC_CDP_URL="${REDDIT_CDP_URL:-$_BH_REDDIT_DEFAULT_URL}" \
-    HC_LAUNCH_URL="about:blank" \
     HC_WINDOW_POS="${BH_REDDIT_WINDOW_POS:-2131,-1032}" \
     HC_WINDOW_SIZE="${BH_REDDIT_WINDOW_SIZE:-911,1016}" \
     HC_PRE_LAUNCH_HOOK=_reddit_defer_if_posting \

package/skill/lib/twitter-backend.sh

@@ -160,7 +160,6 @@ ensure_twitter_browser_for_backend() {
     HC_PROFILE_DIR="$HOME/.claude/browser-profiles/browser-harness" \
     HC_DEFAULT_URL="$_BH_DEFAULT_URL" \
     HC_CDP_URL="${TWITTER_CDP_URL:-$_BH_DEFAULT_URL}" \
-    HC_LAUNCH_URL="${BH_LAUNCH_URL:-https://x.com}" \
     HC_WINDOW_POS="${BH_WINDOW_POS:-3042,-1032}" \
     HC_WINDOW_SIZE="${BH_WINDOW_SIZE:-1024,1013}" \
     HC_EXTRA_FLAGS="--password-store=basic --use-mock-keychain" \