@m13v/s4l 1.7.1-rc.2 → 1.7.1-rc.4

package/mcp/dist/index.js

@@ -1835,6 +1835,18 @@ tool("project_config", {
             // as expected. Once connect_x succeeds, run the full phase immediately
             // to verify persistence, CDP, and the durable cookie mirror.
             doctorReport = await runDoctorPhase("full");
+            // Only mark x_verified once doctor confirms all X checks pass (session valid,
+            // cookies persisted, CDP responding, keychain accessible). This prevents the
+            // autopilot from starting if X connection didn't actually persist.
+            if (doctorReport?.ok) {
+                completeOnboardingMilestone("x_verified", {
+                    x_session: doctorReport.checks?.find(c => c.id === "x_session")?.status,
+                    x_cookies: doctorReport.checks?.find(c => c.id === "x_cookie_sqlite")?.status,
+                });
+            }
+            else {
+                recordOnboardingAttempt("x_verified", { doctor_ok: false });
+            }
         }
         else {
             blockOnboardingMilestone("x_connected", `x_${r.state || "not_connected"}`, r.error || r.note || summarizeXAuth(r), { state: r.state || "not_connected" });
@@ -3225,6 +3237,18 @@ async function ensureQueueKickerInstalled() {
                 detail: "no ready project or active persona yet",
             };
         }
+        // Additional gate: X must be connected and verified before autopilot starts.
+        // This prevents wasted cycles against a logged-out x.com if X connection didn't
+        // persist after import/login. x_verified milestone only completes after doctor
+        // confirms X session and cookies are valid.
+        const onboardingState = onboardingSnapshot();
+        const xVerified = onboardingState?.milestones?.some((m) => m.id === "x_verified" && m.status === "complete");
+        if (!xVerified) {
+            return {
+                ok: false,
+                detail: "X not yet verified (awaiting explicit pre-flight confirmation)",
+            };
+        }
         const logDir = path.join(repoDir(), "skill", "logs");
         try {
             fs.mkdirSync(logDir, { recursive: true });

package/mcp/dist/onboarding.js

@@ -14,6 +14,7 @@ export const ONBOARDING_MILESTONES = [
     "environment_checked",
     "runtime_ready",
     "x_connected",
+    "x_verified",
     "profile_scanned",
     "mode_chosen",
     "project_ready",

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.1-rc.2",
-  "installedAt": "2026-07-07T19:26:54.404Z"
+  "version": "1.7.1-rc.4",
+  "installedAt": "2026-07-07T21:09:29.839Z"
 }

package/mcp/manifest.json

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

@@ -856,12 +856,13 @@ class _ReviewController(NSObject):
             content.addSubview_(deye)
             self._details_btn = deye
 
-        # Editable reply, with the attached link folded in as it'll post (no
-        # separate link field). The trailing link is stripped on send so the
-        # pipeline still mints the tracked /r/<code> short link (no double link).
+        # Editable reply. Since 2026-07-06 the tail link is folded into
+        # reply_text at DRAFT time (scripts/twitter_gen_links.py::apply_tail_link),
+        # so it's normally already there — only append link_url when reply_text
+        # is genuinely link-free (older/fallback plans), else it shows twice.
         reply = d.get("reply_text") or ""
         link = d.get("link_url")
-        composed = f"{reply} {link}" if link else reply
+        composed = reply if (not link or link in reply) else f"{reply} {link}"
         # Non-English draft with a stamped translation: a muted read-only
         # "EN:" block sits between the heading and the editable field so the
         # reviewer reads the draft in English while still editing (and
@@ -1082,23 +1083,19 @@ class _ReviewController(NSObject):
         drop_link = False
         if approved:
             text = self._current_text()
-            # The card folds link_url into the editable field (see _render). On
-            # send we must reconcile what the user did with that link:
-            #   - link still present anywhere -> remove ALL occurrences so the
-            #     poster mints the single tracked /r/<code> short link (no double
-            #     link, no bare URL). Generalizes the old endswith() strip, which
-            #     missed the link whenever the user typed anything after it.
-            #   - link gone (user deleted it while editing) -> drop_link=True so
-            #     the poster does NOT re-append it. Without this signal the post
-            #     pipeline's forced TWITTER_TAIL_LINK_RATE=1.0 silently revived a
-            #     link the user intentionally removed.
-            if link:
-                if link in text:
-                    text = text.replace(link, "")
-                else:
-                    drop_link = True
-            # Collapse only horizontal whitespace left by the removal; preserve
-            # any newlines the user intended.
+            # reply_text already carries the link embedded at draft time (see
+            # _render) — post it as-is, don't strip it back out. tail_link_variant
+            # is stamped before the card is ever shown, so the post pipeline now
+            # trusts reply_text verbatim and never re-adds a missing link; the old
+            # strip-then-hope-the-poster-revives-it logic predates that move and
+            # was mislabeling every approval as "edited" (body != orig once the
+            # link was stripped) and occasionally shipping a tweet with no link
+            # at all. Only signal drop_link when the user actually deleted the
+            # link while editing, so the poster clears link_url instead of
+            # reviving it.
+            if link and link not in text:
+                drop_link = True
+            # Collapse only horizontal whitespace runs; preserve intended newlines.
             body = re.sub(r"[ \t]{2,}", " ", text).strip()
         else:
             body = orig

package/mcp/menubar/s4l_menubar.py

@@ -469,6 +469,24 @@ class S4LMenuBar(rumps.App):
             f"[s4l-menubar] accessibility_trusted={st.accessibility_trusted()}\n"
         )
         sys.stderr.flush()
+        # Status-item visibility watchdog (telemetry only). A live process says
+        # nothing about whether macOS is actually DRAWING our icon: on 2026-07-07
+        # a customer's menu bar process ran for ~25 min with no visible icon
+        # (post-reboot login storm) and support had no signal to tell "process
+        # dead" from "icon hidden". _tick probes the real NSStatusItem every 60s,
+        # persists menubar-state.json (memory_snapshot ships it on the heartbeat)
+        # and logs transitions to stderr. Deliberately NO auto-restart: the
+        # occlusion probe also reads not-visible during fullscreen apps and the
+        # locked screen, so acting on it would false-fire; the remote fix is the
+        # restart_menubar MCP tool.
+        # First probe at +60s, not immediately: the window server takes a few
+        # seconds to place a fresh status item (occlusion reads not-visible and
+        # the frame sits at x=0 until then — measured 2026-07-07), so an eager
+        # probe would log a false "hidden" on every single process start.
+        self._icon_check_due_at = time.monotonic() + 60.0
+        self._icon_hidden_since = None
+        self._icon_last_on_screen = "unprobed"
+        self._icon_watch_started = time.monotonic()
         self._timer = rumps.Timer(self._tick, POLL_SECONDS)
         self._timer.start()
         # Light 1s poll for server activity (scanning/drafting/posting/…); it
@@ -2020,6 +2038,98 @@ class S4LMenuBar(rumps.App):
             self._notify("S4L", f"Resuming {resumed} approved draft(s) after restart…")
 
     # ---- tick: read state, set title, (re)build menu ----------------------
+    def _probe_statusitem(self):
+        """Actual on-screen state of our NSStatusItem: (visible_pref, on_screen).
+
+        visible_pref False = the item was removed from the bar (e.g. the user
+        Cmd-dragged it off). on_screen False with visible_pref True = the item
+        exists but macOS is not drawing it: menu bar full / notch clipping, a
+        status-item render glitch after a login storm, OR a benign fullscreen
+        app / locked screen (why this feeds telemetry, never an automatic
+        action). Two independent signals are recorded because we don't yet know
+        which one is reliable in the field: the window's occlusion state and
+        whether its frame intersects any screen (clipped items get parked
+        off-screen). Either value may be None when the probe can't answer (old
+        macOS, rumps internals moved). Never raises."""
+        try:
+            item = getattr(getattr(self, "_nsapp", None), "nsstatusitem", None)
+            if item is None:
+                return None, None
+            visible_pref = None
+            try:
+                visible_pref = bool(item.isVisible())
+            except Exception:
+                pass
+            on_screen = None
+            try:
+                win = item.button().window()
+                if win is not None:
+                    from AppKit import NSScreen, NSWindowOcclusionStateVisible
+                    occluded_visible = bool(
+                        win.occlusionState() & NSWindowOcclusionStateVisible
+                    )
+                    f = win.frame()
+                    intersects = False
+                    for s in NSScreen.screens():
+                        sf = s.frame()
+                        if (
+                            f.origin.x < sf.origin.x + sf.size.width
+                            and f.origin.x + f.size.width > sf.origin.x
+                            and f.origin.y < sf.origin.y + sf.size.height
+                            and f.origin.y + f.size.height > sf.origin.y
+                        ):
+                            intersects = True
+                            break
+                    on_screen = occluded_visible and intersects
+            except Exception:
+                pass
+            return visible_pref, on_screen
+        except Exception:
+            return None, None
+
+    def _icon_watch_tick(self, now):
+        """60s-throttled visibility probe + menubar-state.json write. See the
+        __init__ comment for why this exists and why it never self-heals."""
+        if now < self._icon_check_due_at:
+            return
+        self._icon_check_due_at = now + 60.0
+        try:
+            visible_pref, on_screen = self._probe_statusitem()
+            if on_screen is False:
+                if self._icon_hidden_since is None:
+                    self._icon_hidden_since = now
+            else:
+                self._icon_hidden_since = None
+            hidden_for = (
+                int(now - self._icon_hidden_since)
+                if self._icon_hidden_since is not None
+                else 0
+            )
+            if on_screen != self._icon_last_on_screen:
+                sys.stderr.write(
+                    f"[s4l-menubar] statusitem on_screen={on_screen} "
+                    f"visible_pref={visible_pref} hidden_for_sec={hidden_for}\n"
+                )
+                sys.stderr.flush()
+                self._icon_last_on_screen = on_screen
+            dest = os.path.join(st.state_dir(), "menubar-state.json")
+            tmp = dest + ".tmp"
+            with open(tmp, "w") as f:
+                json.dump(
+                    {
+                        "ts": time.time(),
+                        "pid": os.getpid(),
+                        "uptime_sec": int(now - self._icon_watch_started),
+                        "statusitem_on_screen": on_screen,
+                        "statusitem_visible_pref": visible_pref,
+                        "hidden_for_sec": hidden_for,
+                    },
+                    f,
+                )
+            os.replace(tmp, dest)
+        except Exception:
+            pass
+
     def _tick(self, _):
         # Post-update verdict: cheap (a single stat when no update is pending).
         try:
@@ -2053,6 +2163,8 @@ class S4LMenuBar(rumps.App):
                         pass
             else:
                 self._resumed = False
+        # Status-item visibility telemetry (60s-throttled inside; see __init__).
+        self._icon_watch_tick(now)
         # The activity spinner owns the TITLE while a tool runs (we don't fight it at
         # 0.12s), but the menu + update indicator must still refresh mid-run —
         # otherwise the "Update now & restart Claude Desktop" item never appears on a box that's always

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.1-rc.2",
+  "version": "1.7.1-rc.4",
   "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.1-rc.2",
+  "version": "1.7.1-rc.4",
   "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/memory_snapshot.py

@@ -604,6 +604,7 @@ def build_snapshot(top_n: int) -> dict[str, Any]:
         "repo_dir": str(REPO_DIR),
         "claude_desktop_version": claude_desktop_version(),
         "reaper": reaper_status(),
+        "menubar": menubar_status(),
         "memory": parse_vm_stat(),
         "process_count": len(rows),
         "top_rss": [
@@ -696,6 +697,7 @@ def build_summary() -> dict[str, Any]:
         "app_version": _app_version(),
         "claude_desktop_version": claude_desktop_version(),
         "reaper": reaper_status(),
+        "menubar": menubar_status(),
         "twitter_cycle": twitter_cycle_status(),
         "process_count": len(rows),
         "mem": {
@@ -765,6 +767,39 @@ def claude_desktop_version() -> str | None:
     return None
 
 
+def menubar_status() -> dict[str, Any] | None:
+    """Last status-item visibility probe written by s4l_menubar._icon_watch_tick(),
+    or None. A live menubar PROCESS says nothing about whether macOS is drawing
+    its icon (2026-07-07: a customer's menubar ran ~25 min icon-less after a
+    reboot and support had no remote signal). Carrying this on the heartbeat
+    makes "process up, icon hidden" diagnosable centrally. age_sec doubles as a
+    process-liveness hint: the menubar rewrites the file every ~60s, so a stale
+    file means the menubar itself is down."""
+    path = (
+        Path(os.environ.get("S4L_STATE_DIR", str(Path.home() / ".social-autoposter-mcp")))
+        / "menubar-state.json"
+    )
+    try:
+        if not path.exists():
+            return None
+        ds = json.loads(path.read_text())
+        age = None
+        try:
+            age = round(time.time() - path.stat().st_mtime, 1)
+        except OSError:
+            pass
+        return {
+            "age_sec": age,  # >150s means the menubar process itself is likely dead
+            "pid": ds.get("pid"),
+            "uptime_sec": ds.get("uptime_sec"),
+            "statusitem_on_screen": ds.get("statusitem_on_screen"),
+            "statusitem_visible_pref": ds.get("statusitem_visible_pref"),
+            "hidden_for_sec": ds.get("hidden_for_sec"),
+        }
+    except Exception:
+        return None
+
+
 def reaper_status() -> dict[str, Any] | None:
     """Last cycle written by reap_stale_claude_sessions.py::write_status(), or None.