@m13v/s4l 1.6.197-rc.13 → 1.6.197-rc.15

package/mcp/dist/index.js

@@ -4004,7 +4004,7 @@ tool("show_browser_to_user", {
         const message = ensured.error === "no_browser"
             ? "No managed Chrome is running right now. Start a draft cycle or autopilot so there's a live browser session to show."
             : ensured.error === "no_websocket"
-                ? "This Node runtime has no WebSocket support (needs Node 21+), so a screencast can't be opened."
+                ? "This runtime has no WebSocket support, so a live screencast can't be opened. Use 'Bring to front' to see the browser window instead."
                 : "Couldn't attach to the browser: " + String(ensured.error);
         return jsonContent({ ok: false, running: false, frame: null, message });
     }

package/mcp/dist/screencast.js

@@ -17,10 +17,24 @@
  * this module is the robust baseline that works regardless.
  */
 import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
 // Untyped indirection: Node ships a global WebSocket at runtime (>=21) but
 // @types/node doesn't always declare it as a value, and MessageEvent isn't typed
 // without the DOM lib. Reach for it dynamically and keep the event handlers `any`.
-const WS = globalThis.WebSocket;
+//
+// Claude Desktop launches this server with whatever `node` is on the user's
+// PATH, which can be 18/20 with no global WebSocket. Fall back to the bundled
+// `ws` package, whose browser-style API (onopen/onmessage/send/close/readyState)
+// matches how this module drives the socket.
+const WS = globalThis.WebSocket ??
+    (() => {
+        try {
+            return createRequire(import.meta.url)("ws").WebSocket;
+        }
+        catch {
+            return undefined;
+        }
+    })();
 // Ports we manage a Chrome on, most-likely-active first. TWITTER_CDP_URL (the
 // twitter harness) wins if set; the rest cover linkedin (9556) / reddit (9557) /
 // browser-harness / assrt.

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.197-rc.13",
-  "installedAt": "2026-07-03T20:22:38.198Z"
+  "version": "1.6.197-rc.15",
+  "installedAt": "2026-07-03T20:53:31.521Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.197-rc.13",
+  "version": "1.6.197-rc.15",
   "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

@@ -22,7 +22,7 @@ entries).
 Overall feedback (guidance not tied to any single thread) has two entry
 points that share one submit handler, registered by the menu bar via
 `set_feedback_handler` (it ships decision='feedback' review events): the
-card's bubble button swaps the card body for an in-window composer (a
+card's Feedback button swaps the card body for an in-window composer (a
 separate floating panel was tried and opened where the user never saw it on
 a multi-monitor setup), and the menu bar's "Send feedback…" item opens the
 standalone `present_feedback(on_submit)` panel (no card window need exist).
@@ -49,6 +49,7 @@ import objc
 from Foundation import (
     NSObject,
     NSMakeRect,
+    NSMakeSize,
     NSAttributedString,
     NSMutableAttributedString,
     NSURL,
@@ -92,6 +93,7 @@ from AppKit import (
     NSEventModifierFlagCommand,
     NSEventModifierFlagShift,
     NSEventModifierFlagDeviceIndependentFlagsMask,
+    NSViewWidthSizable,
 )
 
 # Strong reference to the live controller so pyobjc doesn't GC it mid-review
@@ -306,6 +308,35 @@ def _label(frame, text, *, size=12, bold=False, muted=False):
     return f
 
 
+def _editable_scroll(frame, text=""):
+    """Bezel-bordered scrollable text editor. The document view must be sized
+    to the scroll view's contentSize (NOT the outer frame) and track its width;
+    sized to the outer frame the text runs underneath the scroller. The
+    scroller itself auto-hides so it only appears when the text overflows.
+    Returns (scroll, textview)."""
+    scroll = NSScrollView.alloc().initWithFrame_(frame)
+    scroll.setHasVerticalScroller_(True)
+    scroll.setAutohidesScrollers_(True)
+    scroll.setBorderType_(NS_BEZEL_BORDER)
+    cs = scroll.contentSize()
+    tv = NSTextView.alloc().initWithFrame_(NSMakeRect(0, 0, cs.width, cs.height))
+    tv.setFont_(NSFont.systemFontOfSize_(12))
+    tv.setRichText_(False)
+    tv.setEditable_(True)
+    tv.setSelectable_(True)
+    tv.setVerticallyResizable_(True)
+    tv.setHorizontallyResizable_(False)
+    tv.setMinSize_(NSMakeSize(0, cs.height))
+    tv.setMaxSize_(NSMakeSize(1e7, 1e7))
+    tv.setAutoresizingMask_(NSViewWidthSizable)
+    tv.textContainer().setWidthTracksTextView_(True)
+    tv.textContainer().setContainerSize_(NSMakeSize(cs.width, 1e7))
+    if text:
+        tv.setString_(text)
+    scroll.setDocumentView_(tv)
+    return scroll, tv
+
+
 class _ReviewController(NSObject):
     def initWithDrafts_onDecision_onComplete_(self, drafts, on_decision, on_complete):
         self = objc.super(_ReviewController, self).init()
@@ -504,9 +535,10 @@ class _ReviewController(NSObject):
         content = NSView.alloc().initWithFrame_(NSMakeRect(0, 0, W, H))
 
         # Buttons at the TOP, one line: Approve, Approve 😄 (approve + loved),
-        # a small feedback-bubble icon (overall feedback, decides nothing),
-        # Reject at the right.
-        approve = NSButton.alloc().initWithFrame_(NSMakeRect(M, H - 42, 84, 30))
+        # Feedback (overall feedback, decides nothing), Reject at the right.
+        # Widths are hand-fit so all four bezeled buttons share the 348pt row
+        # without truncating their titles.
+        approve = NSButton.alloc().initWithFrame_(NSMakeRect(M, H - 42, 78, 30))
         approve.setTitle_("Approve")
         approve.setBezelStyle_(NSBezelStyleRounded)
         approve.setTarget_(self)
@@ -518,7 +550,7 @@ class _ReviewController(NSObject):
         # rail sees the difference. Labeled as an approve variant, not a bare
         # emoji: a lone 😄 read as decoration and users doubted the click
         # registered (2026-07-03 feedback).
-        smile = NSButton.alloc().initWithFrame_(NSMakeRect(M + 88, H - 42, 116, 30))
+        smile = NSButton.alloc().initWithFrame_(NSMakeRect(M + 82, H - 42, 100, 30))
         smile.setTitle_("Approve 😄")
         smile.setBezelStyle_(NSBezelStyleRounded)
         smile.setTarget_(self)
@@ -529,22 +561,16 @@ class _ReviewController(NSObject):
             pass
         content.addSubview_(smile)
 
-        # Feedback bubble = overall feedback (about the pipeline, not this
-        # draft). Swaps the card body for the composer IN THIS WINDOW; a
-        # separate floating panel was tried first and opened somewhere the
-        # user never saw on a multi-monitor setup (2026-07-03: 7 clicks,
-        # zero sightings). SF Symbol, like the stats eye; emoji 💬 rendered
-        # as a grey three-dots glyph nobody could identify.
-        fb = NSButton.alloc().initWithFrame_(NSMakeRect(M + 212, H - 40, 28, 26))
-        fb.setBordered_(False)
-        fb_img = NSImage.imageWithSystemSymbolName_accessibilityDescription_(
-            "bubble.left", "overall feedback"
-        )
-        if fb_img is not None:
-            fb.setImage_(fb_img)
-            fb.setTitle_("")
-        else:  # pre-Big Sur fallback: no SF Symbols
-            fb.setTitle_("💬")
+        # Feedback = overall feedback (about the pipeline, not this draft).
+        # Swaps the card body for the composer IN THIS WINDOW; a separate
+        # floating panel was tried first and opened somewhere the user never
+        # saw on a multi-monitor setup (2026-07-03: 7 clicks, zero sightings).
+        # A borderless bubble.left icon was tried next and read as decoration,
+        # not a button; a labeled bezel button matching its row mates won
+        # (2026-07-03 feedback).
+        fb = NSButton.alloc().initWithFrame_(NSMakeRect(M + 186, H - 42, 90, 30))
+        fb.setTitle_("Feedback")
+        fb.setBezelStyle_(NSBezelStyleRounded)
         fb.setTarget_(self)
         fb.setAction_("feedbackOpen:")
         try:
@@ -553,7 +579,7 @@ class _ReviewController(NSObject):
             pass
         content.addSubview_(fb)
 
-        reject = NSButton.alloc().initWithFrame_(NSMakeRect(W - M - 84, H - 42, 84, 30))
+        reject = NSButton.alloc().initWithFrame_(NSMakeRect(W - M - 66, H - 42, 66, 30))
         reject.setTitle_("Reject")
         reject.setBezelStyle_(NSBezelStyleRounded)
         reject.setTarget_(self)
@@ -703,18 +729,9 @@ class _ReviewController(NSObject):
         reply = d.get("reply_text") or ""
         link = d.get("link_url")
         composed = f"{reply} {link}" if link else reply
-        scroll = NSScrollView.alloc().initWithFrame_(
-            NSMakeRect(M, M, W - 2 * M, H - 172 - M - 6)
+        scroll, tv = _editable_scroll(
+            NSMakeRect(M, M, W - 2 * M, H - 172 - M - 6), composed
         )
-        scroll.setHasVerticalScroller_(True)
-        scroll.setBorderType_(NS_BEZEL_BORDER)
-        tv = NSTextView.alloc().initWithFrame_(NSMakeRect(0, 0, W - 2 * M, 100))
-        tv.setFont_(NSFont.systemFontOfSize_(12))
-        tv.setRichText_(False)
-        tv.setEditable_(True)
-        tv.setSelectable_(True)
-        tv.setString_(composed)
-        scroll.setDocumentView_(tv)
         content.addSubview_(scroll)
         self._textview = tv
 
@@ -988,17 +1005,7 @@ class _ReviewController(NSObject):
                 muted=True,
             )
         )
-        scroll = NSScrollView.alloc().initWithFrame_(
-            NSMakeRect(M, 54, W - 2 * M, H - 86 - 54)
-        )
-        scroll.setHasVerticalScroller_(True)
-        scroll.setBorderType_(NS_BEZEL_BORDER)
-        tv = NSTextView.alloc().initWithFrame_(NSMakeRect(0, 0, W - 2 * M, 100))
-        tv.setFont_(NSFont.systemFontOfSize_(12))
-        tv.setRichText_(False)
-        tv.setEditable_(True)
-        tv.setSelectable_(True)
-        scroll.setDocumentView_(tv)
+        scroll, tv = _editable_scroll(NSMakeRect(M, 54, W - 2 * M, H - 86 - 54))
         content.addSubview_(scroll)
         self._feedback_tv = tv
 
@@ -1256,7 +1263,7 @@ def heal_active():
 # ---- overall-feedback composer ----------------------------------------------
 # One small floating panel with a free-text field, for guidance that is about
 # the PIPELINE rather than any single draft ("less shilling", "more dev
-# threads", ...). Reachable from the card's 💬 button and the menu bar's
+# threads", ...). Reachable from the card's Feedback button and the menu bar's
 # "Send feedback…" item; both call present_feedback(), which falls back to the
 # handler the menu bar registered at boot via set_feedback_handler() (that
 # handler ships a decision='feedback' review event down the same outbox rail
@@ -1265,7 +1272,7 @@ def heal_active():
 FB_W = 380
 FB_H = 200
 
-# Default submit handler (menu bar's shipper). Module-level so the card's 💬
+# Default submit handler (menu bar's shipper). Module-level so the card's
 # button can open the composer without threading a callback through
 # present_review's signature.
 _feedback_handler = None
@@ -1341,19 +1348,9 @@ class _FeedbackController(NSObject):
                 muted=True,
             )
         )
-        scroll = NSScrollView.alloc().initWithFrame_(
+        scroll, tv = _editable_scroll(
             NSMakeRect(M, 54, FB_W - 2 * M, FB_H - 48 - 8 - 54)
         )
-        scroll.setHasVerticalScroller_(True)
-        scroll.setBorderType_(NS_BEZEL_BORDER)
-        tv = NSTextView.alloc().initWithFrame_(
-            NSMakeRect(0, 0, FB_W - 2 * M, 80)
-        )
-        tv.setFont_(NSFont.systemFontOfSize_(12))
-        tv.setRichText_(False)
-        tv.setEditable_(True)
-        tv.setSelectable_(True)
-        scroll.setDocumentView_(tv)
         content.addSubview_(scroll)
         self._tv = tv
 

package/mcp/menubar/s4l_menubar.py

@@ -1204,16 +1204,6 @@ class S4LMenuBar(rumps.App):
                 continue
         return None, repo
 
-    @staticmethod
-    def _ver_tuple(v):
-        out = []
-        for part in str(v).split("-")[0].split("+")[0].split("."):
-            try:
-                out.append(int(part))
-            except ValueError:
-                out.append(0)
-        return tuple(out)
-
     def _check_update_verdict(self):
         p = self._update_verify_path()
         if not os.path.exists(p):
@@ -1232,7 +1222,14 @@ class S4LMenuBar(rumps.App):
             self._drop_update_marker(p)
             return
         effective, repo = self._effective_version()
-        if effective and self._ver_tuple(effective) >= self._ver_tuple(target):
+        # ONE comparator: st.ver_key delegates to scripts/snapshot.py::_ver_key
+        # (rc-aware). If the snapshot module can't load this tick, skip the
+        # verdict; the grace window below still resolves the marker either way.
+        try:
+            settled = bool(effective) and st.ver_key(effective) >= st.ver_key(target)
+        except Exception:
+            settled = False
+        if settled:
             self._drop_update_marker(p)
             self._notify("S4L updated", f"Now on v{effective}.")
             return
@@ -2370,7 +2367,17 @@ class S4LMenuBar(rumps.App):
         items.append(rumps.separator)
         items.append(rumps.MenuItem("Open dashboard", callback=self._open_dashboard))
         items.append(rumps.MenuItem("Send feedback…", callback=self._menu_feedback))
-        if self._update_available and self._latest_version:
+        # While the update-verify marker is pending, the pipeline copy still
+        # resolves the OLD version (it only advances once the restarted server
+        # re-provisions repo/package, ~2 min), so the snapshot honestly reports
+        # update_available and the menu re-showed "update to vN" right after
+        # the user clicked update — reading as a failed install (2026-07-03).
+        # Show the in-progress state instead; _check_update_verdict drops the
+        # marker on success or after UPDATE_VERIFY_GRACE_SEC either way.
+        if os.path.exists(self._update_verify_path()):
+            items.append(rumps.separator)
+            items.append(self._label("⏳ Finishing update… verifying install"))
+        elif self._update_available and self._latest_version:
             items.append(rumps.separator)
             items.append(self._label(f"⬆ Update available · v{self._latest_version}"))
             items.append(

package/mcp/menubar/s4l_state.py

@@ -222,7 +222,7 @@ _snap_lock = threading.Lock()
 _snap_refreshing = [False]
 
 
-def _compute_snapshot_full():
+def _snapshot_module():
     repo = (
         os.environ.get("S4L_REPO_DIR")
         or os.environ.get("SAPS_REPO_DIR")  # pre-rename plists (2026-07-03)
@@ -232,7 +232,19 @@ def _compute_snapshot_full():
     if scripts not in sys.path:
         sys.path.insert(0, scripts)
     import snapshot as _snapshot_mod  # scripts/snapshot.py
-    return _snapshot_mod.compute()
+    return _snapshot_mod
+
+
+def _compute_snapshot_full():
+    return _snapshot_module().compute()
+
+
+def ver_key(v):
+    """rc-aware version precedence key, delegated to scripts/snapshot.py::
+    _ver_key so there is exactly ONE Python implementation (kept in lockstep
+    with mcp/src/version.ts::verKey). The update verifier used to carry its
+    own third copy, which drifted rc-blind (2026-07-03); do not re-add one."""
+    return _snapshot_module()._ver_key(v)
 
 
 def _refresh_snapshot_bg():

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.6.197-rc.13",
+  "version": "1.6.197-rc.15",
   "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",
@@ -23,6 +23,7 @@
     "@modelcontextprotocol/ext-apps": "^1.7.3",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@sentry/node": "^10.58.0",
+    "ws": "^8.21.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l",
-  "version": "1.6.197-rc.13",
+  "version": "1.6.197-rc.15",
   "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/linkedin_presence.py

@@ -1,15 +1,22 @@
 #!/usr/bin/env python3
 """Read-only LinkedIn presence pass through the existing harness Chrome.
 
-This helper is deliberately small and deterministic:
+Simulates a short human browsing session:
   - attach to the already-running linkedin-harness Chrome via CDP
-  - reuse the existing tab/context
-  - navigate to one first-party LinkedIn surface
-  - perform a bounded number of mouse-wheel scrolls with short dwell periods
-  - never click, type, post, react, message, open permalinks, or call Voyager
+  - start on one first-party LinkedIn surface
+  - random walk of scrolls, dwells, and read-only navigation clicks
+    (top nav tabs, profile links from the feed, company pages,
+    LinkedIn News stories), with occasional back-navigation
+
+Hard safety rules:
+  - clicks ONLY <a href> elements whose URL matches a strict allowlist of
+    read-only linkedin.com surfaces; never clicks buttons or coordinates
+  - never likes, follows, connects, messages, comments, posts, or types
+  - never opens messaging conversations or external domains
+  - never calls Voyager
 
 The shell wrapper owns scheduling, locking, killswitch checks, and run_monitor
-logging. This Python file only does the browser action.
+logging. This Python file only does the browser session.
 """
 
 from __future__ import annotations
@@ -17,6 +24,8 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import random
+import re
 import sys
 import time
 from typing import Any
@@ -25,25 +34,79 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from linkedin_browser import _connect_to_running_or_launch, _is_login_or_checkpoint  # noqa: E402
 
 
-MODE_URLS = {
+START_URLS = {
     "feed": "https://www.linkedin.com/feed/",
     "notifications": "https://www.linkedin.com/notifications/",
-    "messaging": "https://www.linkedin.com/messaging/",
+    "mynetwork": "https://www.linkedin.com/mynetwork/",
     "profile": "https://www.linkedin.com/in/me/",
 }
+# Feed-heavy start distribution: (surface, weight)
+START_WEIGHTS = [("feed", 55), ("notifications", 20), ("mynetwork", 15), ("profile", 10)]
+
+# Click allowlist: read-only destinations only. Matched against href with the
+# query string stripped. Anything not matching is never clicked.
+CLICK_ALLOWLIST = {
+    "nav": re.compile(
+        r"^https://www\.linkedin\.com/(feed|mynetwork|notifications|jobs)/?$"
+    ),
+    "profile": re.compile(r"^https://www\.linkedin\.com/in/[^/?#]+/?$"),
+    "company": re.compile(
+        r"^https://www\.linkedin\.com/company/[^/?#]+/?(posts/?|about/?)?$"
+    ),
+    "news": re.compile(r"^https://www\.linkedin\.com/news/[^?#]+$"),
+}
 
+# Random-walk action distribution: (action, weight)
+ACTION_WEIGHTS = [
+    ("scroll", 38),
+    ("read", 14),
+    ("scroll_up", 8),
+    ("click_nav", 12),
+    ("click_profile", 14),
+    ("click_company", 7),
+    ("click_news", 7),
+]
+
+CLICK_CATEGORY = {
+    "click_nav": "nav",
+    "click_profile": "profile",
+    "click_company": "company",
+    "click_news": "news",
+}
 
-def _csv_ints(raw: str, fallback: list[int]) -> list[int]:
-    out: list[int] = []
-    for part in (raw or "").split(","):
-        part = part.strip()
-        if not part:
-            continue
-        try:
-            out.append(int(part))
-        except ValueError:
-            continue
-    return out or list(fallback)
+ANCHOR_SCAN_JS = """
+() => {
+  const vh = window.innerHeight, vw = window.innerWidth;
+  const out = [];
+  const seen = new Set();
+  for (const a of document.querySelectorAll('a[href]')) {
+    const href = a.href || '';
+    const attr = a.getAttribute('href') || '';
+    if (!href.startsWith('https://www.linkedin.com/')) continue;
+    if (href.includes('"') || attr.includes('"')) continue;
+    const r = a.getBoundingClientRect();
+    if (r.width < 24 || r.height < 10) continue;
+    if (r.bottom < 0 || r.top > vh || r.right < 20 || r.left > vw - 20) continue;
+    const key = href.split('?')[0];
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({href: href, attr: attr, text: (a.innerText || '').trim().slice(0, 60)});
+    if (out.length >= 150) break;
+  }
+  return out;
+}
+"""
+
+
+def _weighted_choice(pairs: list[tuple[str, int]]) -> str:
+    total = sum(w for _, w in pairs)
+    roll = random.uniform(0, total)
+    acc = 0.0
+    for name, w in pairs:
+        acc += w
+        if roll <= acc:
+            return name
+    return pairs[-1][0]
 
 
 def _pick_page(context: Any) -> Any:
@@ -67,130 +130,243 @@ def _safe_eval(page: Any, expr: str, fallback: Any) -> Any:
         return fallback
 
 
-def _session_invalid(page: Any, mode: str) -> tuple[bool, str]:
+def _session_invalid(page: Any) -> tuple[bool, str]:
     url = page.url or ""
     title = _safe_title(page)
-    url_l = url.lower()
-    title_l = title.lower()
-    if _is_login_or_checkpoint(url_l):
+    if _is_login_or_checkpoint(url.lower()):
         return True, f"url:{url}"
-    if any(s in title_l for s in ("security verification", "captcha", "checkpoint")):
+    if any(s in title.lower() for s in ("security verification", "captcha", "checkpoint")):
         return True, f"title:{title}"
-
-    # Avoid reading private message preview text in messaging mode. The shared
-    # shell-level detect-gate has already verified /feed/ before this helper
-    # runs, and URL/title catch the authwall redirects here.
-    if mode == "messaging":
+    # Skip body-text markers on messaging (private previews); URL/title cover it.
+    if "/messaging" in url:
         return False, ""
-
     text = _safe_eval(
         page,
         "() => (document.body && document.body.innerText || '').slice(0, 1200)",
         "",
     )
     text_l = str(text or "").lower()
-    bad_text_markers = (
+    for marker in (
         "security verification",
         "verify you are human",
         "captcha",
         "sign in to linkedin",
         "join linkedin",
-    )
-    for marker in bad_text_markers:
+    ):
         if marker in text_l:
             return True, f"text:{marker}"
     return False, ""
 
 
-def _viewport_point(page: Any) -> tuple[int, int]:
+def _settle(page: Any) -> None:
+    try:
+        page.wait_for_load_state("domcontentloaded", timeout=15000)
+    except Exception:
+        pass
+    page.wait_for_timeout(random.randint(1500, 3200))
+
+
+def _scroll(page: Any, up: bool = False) -> None:
     dims = _safe_eval(
         page,
         "() => ({w: window.innerWidth || 1180, h: window.innerHeight || 900})",
         {"w": 1180, "h": 900},
     )
-    if not isinstance(dims, dict):
-        dims = {"w": 1180, "h": 900}
-    w = int(dims.get("w") or 1180)
-    h = int(dims.get("h") or 900)
-    return max(1, int(w * 0.50)), max(1, int(h * 0.56))
+    w = int((dims or {}).get("w") or 1180)
+    h = int((dims or {}).get("h") or 900)
+    x = int(w * random.uniform(0.35, 0.62))
+    y = int(h * random.uniform(0.40, 0.68))
+    try:
+        page.mouse.move(x, y, steps=random.randint(4, 12))
+    except Exception:
+        pass
+    amount = random.randint(380, 760)
+    if up:
+        amount = -random.randint(240, 520)
+    page.mouse.wheel(0, amount)
+    time.sleep(random.uniform(1.2, 4.5))
+
+
+def _candidate_links(page: Any, category: str, visited: set[str]) -> list[dict]:
+    anchors = _safe_eval(page, ANCHOR_SCAN_JS, []) or []
+    rx = CLICK_ALLOWLIST[category]
+    current = (page.url or "").split("?")[0].rstrip("/")
+    out = []
+    for a in anchors:
+        href = str(a.get("href") or "")
+        attr = str(a.get("attr") or "")
+        base = href.split("?")[0]
+        if not attr or not rx.match(base):
+            continue
+        if base.rstrip("/") == current:
+            continue
+        if base in visited and category != "nav":
+            continue
+        out.append({"href": href, "attr": attr})
+    return out
+
+
+def _click_link(context: Any, page: Any, link: dict) -> tuple[Any, bool]:
+    """Click the anchor with this exact href attribute. Returns (page, navigated)."""
+    before_url = page.url
+    before_pages = len(context.pages)
+    loc = page.locator(f'a[href="{link["attr"]}"]').first
+    try:
+        loc.scroll_into_view_if_needed(timeout=4000)
+        page.wait_for_timeout(random.randint(300, 900))
+        loc.click(timeout=5000, delay=random.randint(40, 140))
+    except Exception:
+        return page, False
+    page.wait_for_timeout(1200)
+    # target=_blank case: browse briefly in the new tab, then close it.
+    if len(context.pages) > before_pages:
+        new_page = context.pages[-1]
+        try:
+            _settle(new_page)
+            _scroll(new_page)
+            time.sleep(random.uniform(1.0, 3.0))
+            new_page.close()
+        except Exception:
+            pass
+        return page, True
+    _settle(page)
+    return page, page.url != before_url
 
 
 def run(args: argparse.Namespace) -> dict[str, Any]:
-    url = args.url or MODE_URLS.get(args.mode)
-    if not url:
-        return {"ok": False, "error": "bad_mode", "mode": args.mode}
-
-    amounts = _csv_ints(args.amounts, [520])
-    dwells = _csv_ints(args.dwells, [2])
-    scrolls = max(0, min(int(args.scrolls), len(amounts)))
-    amounts = amounts[:scrolls]
-    if len(dwells) < scrolls:
-        dwells.extend([dwells[-1] if dwells else 2] * (scrolls - len(dwells)))
-    dwells = dwells[:scrolls]
+    if args.seed:
+        random.seed(args.seed)
+    start = args.start or _weighted_choice(START_WEIGHTS)
+    start_url = START_URLS.get(start)
+    if not start_url:
+        return {"ok": False, "error": "bad_start", "start": start}
+
+    steps_target = args.steps if args.steps > 0 else random.randint(4, 9)
+    deadline = time.monotonic() + max(30, args.max_seconds)
+    max_navs = 4
+
+    counters = {"scrolls": 0, "clicks": 0, "navs": 0, "reads": 0, "skipped": 0}
+    visited: set[str] = set()
+    trail: list[str] = []
+    back_depth = 0
 
     from playwright.sync_api import sync_playwright
 
     with sync_playwright() as p:
         context, _owns_context = _connect_to_running_or_launch(p, prefer_cdp=True)
         page = _pick_page(context)
-        page.goto(url, wait_until="domcontentloaded", timeout=args.timeout_ms)
-        page.wait_for_timeout(args.settle_ms)
+        page.goto(start_url, wait_until="domcontentloaded", timeout=args.timeout_ms)
+        _settle(page)
 
-        invalid, detail = _session_invalid(page, args.mode)
+        invalid, detail = _session_invalid(page)
         if invalid:
             return {
                 "ok": False,
                 "error": "session_invalid",
                 "detail": detail,
-                "mode": args.mode,
+                "start": start,
                 "url": page.url,
                 "title": _safe_title(page),
             }
+        visited.add((page.url or "").split("?")[0])
+        trail.append(f"open:{start}")
+
+        steps_done = 0
+        while steps_done < steps_target and time.monotonic() < deadline:
+            action = _weighted_choice(ACTION_WEIGHTS)
+            if action in CLICK_CATEGORY and counters["navs"] >= max_navs:
+                action = "scroll"
+
+            if action == "scroll":
+                _scroll(page)
+                counters["scrolls"] += 1
+                trail.append("scroll")
+            elif action == "scroll_up":
+                _scroll(page, up=True)
+                counters["scrolls"] += 1
+                trail.append("scroll_up")
+            elif action == "read":
+                time.sleep(random.uniform(2.5, 7.0))
+                counters["reads"] += 1
+                trail.append("read")
+            else:
+                category = CLICK_CATEGORY[action]
+                links = _candidate_links(page, category, visited)
+                if not links:
+                    counters["skipped"] += 1
+                    trail.append(f"no_{category}")
+                    steps_done += 1
+                    continue
+                link = random.choice(links)
+                page, navigated = _click_link(context, page, link)
+                if navigated:
+                    counters["clicks"] += 1
+                    counters["navs"] += 1
+                    visited.add((page.url or "").split("?")[0])
+                    trail.append(f"{category}->{(page.url or '').split('?')[0]}")
+                    invalid, detail = _session_invalid(page)
+                    if invalid:
+                        return {
+                            "ok": False,
+                            "error": "session_invalid",
+                            "detail": detail,
+                            "start": start,
+                            "url": page.url,
+                            "title": _safe_title(page),
+                            "trail": trail,
+                        }
+                    # Skim the destination a little.
+                    if random.random() < 0.8:
+                        _scroll(page)
+                        counters["scrolls"] += 1
+                    back_depth += 1
+                    # Usually wander back the way a person does.
+                    if category != "nav" and back_depth > 0 and random.random() < 0.65:
+                        try:
+                            page.go_back(wait_until="domcontentloaded", timeout=15000)
+                            _settle(page)
+                            back_depth -= 1
+                            trail.append("back")
+                        except Exception:
+                            pass
+                else:
+                    counters["skipped"] += 1
+                    trail.append(f"miss_{category}")
+            steps_done += 1
 
-        x, y = _viewport_point(page)
-        page.mouse.move(x, y)
-        for amount, dwell in zip(amounts, dwells):
-            page.mouse.wheel(0, amount)
-            time.sleep(max(0, dwell))
-
-        scroll_state = _safe_eval(
-            page,
-            "() => ({x: window.scrollX || 0, y: window.scrollY || 0, h: document.documentElement.scrollHeight || 0})",
-            {},
-        )
         return {
             "ok": True,
-            "mode": args.mode,
+            "start": start,
+            "steps": steps_done,
+            "counters": counters,
+            "pages_visited": sorted(visited),
+            "trail": trail,
             "url": page.url,
             "title": _safe_title(page),
-            "scrolls": scrolls,
-            "amounts": amounts,
-            "dwells": dwells,
-            "point": {"x": x, "y": y},
-            "scroll_state": scroll_state,
         }
 
 
 def main() -> int:
-    ap = argparse.ArgumentParser(description="Run a read-only LinkedIn presence pass")
-    ap.add_argument("--mode", required=True, choices=sorted(MODE_URLS))
-    ap.add_argument("--url", default="")
-    ap.add_argument("--scrolls", type=int, default=1)
-    ap.add_argument("--amounts", default="")
-    ap.add_argument("--dwells", default="")
+    ap = argparse.ArgumentParser(description="Run a read-only LinkedIn presence browse session")
+    ap.add_argument("--start", default="", choices=[""] + sorted(START_URLS))
+    ap.add_argument("--steps", type=int, default=0, help="0 = random 4-9")
+    ap.add_argument("--max-seconds", type=int, default=150)
     ap.add_argument("--timeout-ms", type=int, default=30000)
-    ap.add_argument("--settle-ms", type=int, default=2000)
+    ap.add_argument("--seed", type=int, default=0)
     args = ap.parse_args()
 
     try:
         result = run(args)
     except Exception as e:
-        result = {"ok": False, "error": "exception", "detail": str(e), "mode": args.mode}
+        result = {"ok": False, "error": "exception", "detail": str(e)}
 
     if result.get("ok"):
+        c = result.get("counters") or {}
         print(
             "LINKEDIN_PRESENCE_SUMMARY: "
-            f"mode={result.get('mode')} pages=1 scrolls={result.get('scrolls')} session=ok"
+            f"start={result.get('start')} steps={result.get('steps')} "
+            f"pages={len(result.get('pages_visited') or []) or 1} "
+            f"scrolls={c.get('scrolls', 0)} clicks={c.get('clicks', 0)} session=ok"
         )
         print(json.dumps(result, sort_keys=True))
         return 0

package/skill/lib/linkedin-backend.sh

@@ -300,11 +300,17 @@ ensure_linkedin_browser_for_backend() {
             [ -n "$_stale_pids" ] && { kill -9 $_stale_pids 2>/dev/null || true; sleep 1; }
             rm -f "$_prof_dir/SingletonLock" "$_prof_dir/SingletonSocket" "$_prof_dir/SingletonCookie" 2>/dev/null || true
         fi
+        # The occlusion/backgrounding flags matter: the window sits offscreen,
+        # and without them Chrome stops laying out SPA-rendered content, so
+        # every element measures 0x0 and clicks become impossible (2026-07-03).
         "$_chrome_bin" \
             --remote-debugging-port=9556 \
             --user-data-dir="$HOME/.claude/browser-profiles/browser-harness-linkedin" \
             --no-first-run --no-default-browser-check \
             --disable-features=ChromeWhatsNewUI \
+            --disable-backgrounding-occluded-windows \
+            --disable-renderer-backgrounding \
+            --disable-background-timer-throttling \
             "${_extra[@]}" \
             about:blank >/dev/null 2>&1 &
         disown

package/skill/linkedin-presence.sh

@@ -2,10 +2,13 @@
 # linkedin-presence.sh - read-only LinkedIn session presence pass.
 #
 # Purpose:
-#   Run a bounded, auditable browser pass in the real linkedin-harness Chrome.
-#   It only views first-party LinkedIn surfaces and performs small scroll passes.
-#   It does not like, follow, connect, message, comment, expand comments, or open
-#   post permalinks.
+#   Run a bounded, auditable browsing session in the real linkedin-harness
+#   Chrome. It random-walks first-party LinkedIn surfaces like a person:
+#   scrolls, dwells, clicks read-only links (top nav tabs, profiles from the
+#   feed, company pages, LinkedIn News stories), and navigates back. Clicks
+#   are restricted to an href allowlist of read-only linkedin.com pages.
+#   It does not like, follow, connect, message, comment, or touch any action
+#   button.
 #
 # The shell wrapper is the pipeline: scheduling, killswitch, locks, harness
 # bootstrap, and run_monitor logging. The browser action itself is deterministic
@@ -57,23 +60,9 @@ if [ "$DRY_RUN" != "1" ]; then
     fi
 fi
 
-MODE_ROLL=$(( RANDOM % 4 ))
-case "$MODE_ROLL" in
-    0) MODE="feed"; TARGET_URL="https://www.linkedin.com/feed/" ;;
-    1) MODE="notifications"; TARGET_URL="https://www.linkedin.com/notifications/" ;;
-    2) MODE="messaging"; TARGET_URL="https://www.linkedin.com/messaging/" ;;
-    *) MODE="profile"; TARGET_URL="https://www.linkedin.com/in/me/" ;;
-esac
-
-SCROLLS=$(( 1 + (RANDOM % 3) ))
-DWELL_A=$(( 2 + (RANDOM % 4) ))
-DWELL_B=$(( 2 + (RANDOM % 4) ))
-DWELL_C=$(( 2 + (RANDOM % 4) ))
-SCROLL_A=$(( 420 + (RANDOM % 260) ))
-SCROLL_B=$(( 420 + (RANDOM % 260) ))
-SCROLL_C=$(( 420 + (RANDOM % 260) ))
-
-log "=== LinkedIn Presence Run: $(date) (batch=$BATCH_ID mode=$MODE scrolls=$SCROLLS) ==="
+# The browse session itself (start surface, action mix, scrolls, clicks,
+# dwells) is randomized inside scripts/linkedin_presence.py.
+log "=== LinkedIn Presence Run: $(date) (batch=$BATCH_ID) ==="
 
 # shellcheck source=/dev/null
 [ -f "$HOME/social-autoposter/.env" ] && source "$HOME/social-autoposter/.env"
@@ -90,12 +79,24 @@ log_presence_run() {
     cost=$(python3 "$REPO_DIR/scripts/get_run_cost.py" \
         --since "$RUN_START" --scripts "linkedin-presence" 2>/dev/null || echo "0.0000")
 
+    # Pull the real session shape from the python summary line if present.
+    local scan="pages=1,scrolls=0,clicks=0"
+    local summary
+    summary=$(grep -o "LINKEDIN_PRESENCE_SUMMARY: .*" "$LOG_FILE" 2>/dev/null | tail -1)
+    if [ -n "$summary" ]; then
+        local pages scrolls clicks
+        pages=$(echo "$summary" | sed -n 's/.*pages=\([0-9]*\).*/\1/p')
+        scrolls=$(echo "$summary" | sed -n 's/.*scrolls=\([0-9]*\).*/\1/p')
+        clicks=$(echo "$summary" | sed -n 's/.*clicks=\([0-9]*\).*/\1/p')
+        scan="pages=${pages:-1},scrolls=${scrolls:-0},clicks=${clicks:-0}"
+    fi
+
     local args=(
         "$REPO_DIR/scripts/log_run.py" --script "presence_linkedin"
         --posted 0 --skipped 0 --failed "$failed"
         --cost "$cost" --elapsed "$elapsed"
         --scanned 1 --checked 1
-        --scan "pages=1,scrolls=$SCROLLS"
+        --scan "$scan"
     )
     if [ -n "$failure_reasons" ]; then
         args+=(--failure-reasons "$failure_reasons")
@@ -115,7 +116,7 @@ cleanup() {
 trap cleanup EXIT INT TERM HUP
 
 if [ "$DRY_RUN" = "1" ]; then
-    log "DRY_RUN: would run mode=$MODE url=$TARGET_URL scrolls=$SCROLLS"
+    log "DRY_RUN: would run a randomized read-only browse session"
     exit 0
 fi
 
@@ -138,17 +139,14 @@ fi
 PRESENCE_RC=0
 PYTHON_BIN="${LINKEDIN_DISCOVER_PYTHON:-python3}"
 TIMEOUT_BIN="$(command -v gtimeout || command -v timeout || true)"
+PRESENCE_STEPS="${LINKEDIN_PRESENCE_STEPS:-0}"
 set +e
 if [ -n "$TIMEOUT_BIN" ]; then
-    "$TIMEOUT_BIN" 180 "$PYTHON_BIN" "$REPO_DIR/scripts/linkedin_presence.py" \
-        --mode "$MODE" --url "$TARGET_URL" --scrolls "$SCROLLS" \
-        --amounts "$SCROLL_A,$SCROLL_B,$SCROLL_C" \
-        --dwells "$DWELL_A,$DWELL_B,$DWELL_C" 2>&1 | tee -a "$LOG_FILE"
+    "$TIMEOUT_BIN" 300 "$PYTHON_BIN" "$REPO_DIR/scripts/linkedin_presence.py" \
+        --steps "$PRESENCE_STEPS" --max-seconds 200 2>&1 | tee -a "$LOG_FILE"
 else
     "$PYTHON_BIN" "$REPO_DIR/scripts/linkedin_presence.py" \
-        --mode "$MODE" --url "$TARGET_URL" --scrolls "$SCROLLS" \
-        --amounts "$SCROLL_A,$SCROLL_B,$SCROLL_C" \
-        --dwells "$DWELL_A,$DWELL_B,$DWELL_C" 2>&1 | tee -a "$LOG_FILE"
+        --steps "$PRESENCE_STEPS" --max-seconds 200 2>&1 | tee -a "$LOG_FILE"
 fi
 PRESENCE_RC=${PIPESTATUS[0]}
 set -e