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

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.7-rc.1",
-  "installedAt": "2026-07-30T22:08:01.831Z"
+  "version": "1.7.7-rc.3",
+  "installedAt": "2026-07-30T22:30:41.307Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.7-rc.1",
+  "version": "1.7.7-rc.3",
   "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/package.json

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

@@ -99,7 +99,22 @@ def _reddit_page(pw):
     try:
         browser = pw.chromium.connect_over_cdp(ws)
         ctx = browser.contexts[0] if browser.contexts else browser.new_context()
-        page = ctx.new_page()
+        # Reuse an existing reddit tab instead of new_page(). new_page() opens
+        # a fresh tab on the reddit homepage and STEALS OS FOCUS every call —
+        # this ran ~per-strike and was the reddit focus-pop the other reddit
+        # helpers (reddit_browser / reddit_browser_fetch) already fixed but
+        # this 2026-07-17 ban-check never did. Navigating a background tab does
+        # not pop. Prefer a tab already on reddit.com; else pages[0]; else
+        # create one. Left OPEN for reuse (cleanup_harness_tabs trims to one).
+        page = None
+        for pg in ctx.pages:
+            if "reddit.com" in (pg.url or "") and "login" not in (pg.url or ""):
+                page = pg
+                break
+        if page is None and ctx.pages:
+            page = ctx.pages[0]
+        if page is None:
+            page = ctx.new_page()
         page.set_default_timeout(20000)
         return browser, page
     except Exception:

package/skill/engage-linkedin.sh

@@ -278,34 +278,8 @@ RESET_COUNT=$(li_reset_processing 2)
 
 PENDING_COUNT=$(li_reply_count pending)
 
-# ---- PACING PREFLIGHT (the enforceable half of the pacing gate) -----------
-# The per-reply Step 3b gate inside the Phase B prompt is the fine-grained
-# control, but it depends on the model obeying an instruction. This preflight
-# is the hard stop: when a 24h/72h ceiling is already blown there is nothing
-# Phase B could legally post, so we skip the phase before paying for browser
-# bootstrap, the pending pull and a Claude run.
-#
-# rc=78 ("stop") zeroes PENDING_COUNT rather than exiting, deliberately: an
-# early exit here would skip the run summary and the dashboard metric line at
-# the bottom of this script, and a pipeline that goes quiet WITHOUT reporting
-# is precisely how the 2026-07-20 outage stayed invisible for nine days.
-# rc=75 ("wait") still enters the phase; the per-reply gate sleeps the short
-# remainder itself.
-_LI_PACE_RC=0
-_LI_PACE_OUT="$("$PY_BIN" "$REPO_DIR/scripts/linkedin_pacing.py" check 2>&1)" || _LI_PACE_RC=$?
-log "PACING: $_LI_PACE_OUT"
-if [ "$_LI_PACE_RC" -eq 78 ] && [ "$PENDING_COUNT" -ne 0 ]; then
-    log "PACING: ceiling reached; skipping Phase B this fire ($PENDING_COUNT rows stay pending)"
-    PENDING_COUNT=0
-    LI_PACED_OUT=1
-fi
-
 if [ "$PENDING_COUNT" -eq 0 ]; then
-    if [ "${LI_PACED_OUT:-0}" -eq 1 ]; then
-        log "Phase B: held back by the pacing gate, not by an empty queue."
-    else
-        log "Phase B: No pending LinkedIn replies. Done!"
-    fi
+    log "Phase B: No pending LinkedIn replies. Done!"
 else
     log "Phase B: $PENDING_COUNT pending LinkedIn replies to process"
 
@@ -493,24 +467,6 @@ MANDATORY reply flow for every item:
           mode ($PICKED_MODE=invent) craft a NEW snake_case style name not in the
           curated block above and pass it as the [engagement_style] arg in Step 5.
           Professional but casual. NEVER em dashes. Match parent post language.
-  Step 3b: PACING GATE - MANDATORY, run this IMMEDIATELY BEFORE every single
-          post in Step 4. Never post two replies without a fresh check in
-          between; never batch several posts behind one check.
-             python3 $REPO_DIR/scripts/linkedin_pacing.py check --json
-          Read the JSON "action" field and obey it exactly:
-            "allow" (exit 0) -> proceed to Step 4 for THIS reply only.
-            "wait"  (exit 75) -> sleep the returned "wait_seconds", then
-                                 re-run the check. If it still says wait after
-                                 3 attempts, LEAVE the row pending (do NOT mark
-                                 skipped) and move to the next reply; the next
-                                 cycle will pick it up.
-            "stop"  (exit 78) -> a 24h/72h ceiling is blown. STOP POSTING
-                                 ENTIRELY for this run. Leave all remaining
-                                 rows pending and finish the run cleanly.
-          Do NOT try to out-think, average, or "catch up on" this gate; it is
-          the control that keeps our comment cadence from looking like a
-          metronome. On 2026-07-20 an unpaced run put 23 comments out in 22
-          minutes at 60s +/- 29s and the session was killed that evening.
   Step 4: post reply (OAuth API first, browser fallback)
   Step 5: python3 reply_db.py replied ID "text" [url] [engagement_style] [is_recommendation]   <- mark AFTER success. engagement_style is the style name you applied (in USE mode the assigned '${PICKED_STYLE}'). is_recommendation="1" only when you mentioned a project (Tier 2/3).
 If Step 5 fails, the item stays 'processing' and will be reset to 'pending' on the next run.

package/scripts/linkedin_pacing.py

@@ -1,318 +0,0 @@
-#!/usr/bin/env python3
-"""LinkedIn action pacing gate.
-
-Single source of truth for "is it safe to post another LinkedIn comment right
-now, or should we wait / stop for today". Every LinkedIn write path calls
-`check` immediately BEFORE each comment and honours the answer.
-
-Why this exists
----------------
-Until 2026-07-29 the LinkedIn write path had NO pacing control at all: no
-minimum gap, no jitter, no hourly cap, no per-day cap. The human-looking cadence
-on healthy days was an accident of queue availability and lock contention, not a
-control. Observed inter-action gaps routinely bottomed out at 0-3 SECONDS.
-
-TWO ACTION STREAMS - counting only one is the trap
---------------------------------------------------
-LinkedIn writes land in two different tables and BOTH must be counted:
-
-    replies (replied_at)  engage-linkedin.sh - replying to comments on our posts
-    posts   (posted_at)   run-linkedin.sh    - commenting on others' posts,
-                                               via log_post.py, status='active'
-
-The first cut of this gate counted only `replies` and therefore saw ~25% of
-reality: it read 2026-07-20 as 23 actions when the true figure was 90, and read
-2026-07-19 as ZERO when it was 73. Any future edit that narrows this query to a
-single table silently disables most of the gate. Only rows with status='active'
-count as real writes; log_post.py also records rejected candidates.
-
-What the data does and does NOT support
----------------------------------------
-Combined-stream daily figures, 2026-07-06..07-20:
-
-    n/day      65 .. 96 actions
-    per hour   2.9 .. 4.4
-    CV         0.32 .. 1.26   on EVERY day, healthy or not
-
-An earlier draft of this file claimed CV (sd/mean of inter-action gaps)
-separated logout days from healthy ones at ~1.0. That was an artifact of the
-replies-only subsample. On the full stream it does NOT separate: 2026-07-14 ran
-96 actions at CV 0.72 with no logout, and 2026-07-20 ran 90 at CV 0.78 and was
-killed. We therefore do NOT rely on CV as a predictor; it is retained only at a
-very low floor to catch a true metronome, which remains bad regardless of
-whether it predicts a logout.
-
-Stated plainly: we have NO statistic that reliably separates logout days from
-healthy days. What we do know is (a) this account is flagged, in LinkedIn's own
-words ("temporary restriction for automated activity" twice, "automation tool
-detected" once), (b) every active stretch so far has ended in a session kill,
-6 for 6, and (c) 65-96 automated actions a day with sub-second minimum gaps is
-indefensible in absolute terms whatever the trigger turns out to be. The
-ceilings below are therefore a deliberate ~70% volume cut chosen on judgment,
-NOT a proven safe operating point. Revise them as evidence accumulates.
-
-Ceilings (env-overridable, see CONFIG below):
-    min gap            120s   hard floor; observed minimum was 0-3s
-    per rolling 1h     4      observed average was 2.9-4.4/h with bursts
-    per rolling 24h    25     observed 65-96/day
-    per rolling 72h    60     observed ~230/3d
-    CV floor           0.25   true-metronome catch only; NOT a logout predictor
-    min daily spread   4h     actions must not bunch into one short window
-
-CLI
----
-    linkedin_pacing.py check            # exit 0 = post now, 75 = wait, 78 = stop
-    linkedin_pacing.py check --json     # machine-readable decision
-    linkedin_pacing.py status           # current counters, always exit 0
-
-Exit codes are distinct so a shell caller can tell "wait" from "stop for now":
-    0  -> allowed, post now
-    75 -> not yet; sleep `wait_seconds` then re-check (EX_TEMPFAIL-ish)
-    78 -> a ceiling is blown; do not post at all this run (matches the repo's
-          existing rc=78 "skip this fire" convention)
-
-FAIL-CLOSED: if the database cannot be read we deny (rc=78). The account is
-already flagged; posting blind is worse than skipping a cycle. This mirrors the
-existing "db_unavailable -> script already fails closed" rule in run-linkedin.sh.
-"""
-
-import argparse
-import json
-import os
-import random
-import statistics
-import sys
-from datetime import datetime, timedelta, timezone
-
-
-# --------------------------------------------------------------------------
-# CONFIG - every value env-overridable so we can tune without editing a frozen
-# file, and so tests can drive it against throwaway numbers.
-# --------------------------------------------------------------------------
-def _envf(name, default):
-    try:
-        return float(os.environ[name])
-    except (KeyError, ValueError):
-        return default
-
-
-def _envi(name, default):
-    try:
-        return int(os.environ[name])
-    except (KeyError, ValueError):
-        return default
-
-
-MIN_GAP_S      = _envi("LI_PACE_MIN_GAP_S", 120)
-CV_FLOOR       = _envf("LI_PACE_CV_FLOOR", 0.25)
-CV_WINDOW      = _envi("LI_PACE_CV_WINDOW", 10)
-MAX_PER_1H     = _envi("LI_PACE_MAX_1H", 4)
-MAX_PER_24H    = _envi("LI_PACE_MAX_24H", 25)
-MAX_PER_72H    = _envi("LI_PACE_MAX_72H", 60)
-MIN_SPREAD_S   = _envi("LI_PACE_MIN_SPREAD_S", 4 * 3600)
-# When CV is too low we do not just wait the floor, we inject a long randomized
-# pause to actively break the metronome and pull CV back up.
-CV_PAUSE_MIN_S = _envi("LI_PACE_CV_PAUSE_MIN_S", 900)
-CV_PAUSE_MAX_S = _envi("LI_PACE_CV_PAUSE_MAX_S", 3600)
-
-PLATFORM = "linkedin"
-
-RC_ALLOW = 0
-RC_WAIT = 75
-RC_STOP = 78
-
-
-def _database_url():
-    url = os.environ.get("DATABASE_URL")
-    if url:
-        return url.strip().strip('"').strip("'")
-    env_path = os.path.expanduser("~/social-autoposter/.env")
-    try:
-        with open(env_path, encoding="utf-8") as fh:
-            for line in fh:
-                line = line.strip()
-                if line.startswith("DATABASE_URL="):
-                    return line.split("=", 1)[1].strip().strip('"').strip("'")
-    except OSError:
-        pass
-    return None
-
-
-def _recent_timestamps(hours=72):
-    """Every LinkedIn write action in the last `hours`, UTC, ascending.
-
-    UNION of BOTH write streams. See the module docstring: counting only one
-    table silently disables most of this gate.
-
-    Raises on any failure so callers can fail closed.
-    """
-    import psycopg2  # imported lazily so `--help` works without the driver
-
-    url = _database_url()
-    if not url:
-        raise RuntimeError("DATABASE_URL not resolvable")
-    since = datetime.now(timezone.utc) - timedelta(hours=hours)
-    conn = psycopg2.connect(url, connect_timeout=10)
-    try:
-        with conn.cursor() as cur:
-            cur.execute(
-                "select ts from ("
-                "  select posted_at as ts from posts"
-                "   where platform = %s and status = 'active'"
-                "     and posted_at is not null and posted_at >= %s"
-                "  union all"
-                "  select replied_at as ts from replies"
-                "   where platform = %s"
-                "     and replied_at is not null and replied_at >= %s"
-                ") a order by ts",
-                (PLATFORM, since, PLATFORM, since),
-            )
-            return [r[0] for r in cur.fetchall()]
-    finally:
-        conn.close()
-
-
-def _gaps(ts):
-    return [
-        (b - a).total_seconds()
-        for a, b in zip(ts, ts[1:])
-        if (b - a).total_seconds() >= 0
-    ]
-
-
-def _cv(gaps):
-    """Coefficient of variation. None when undefined (need >= 2 gaps)."""
-    if len(gaps) < 2:
-        return None
-    mean = statistics.fmean(gaps)
-    if mean <= 0:
-        return 0.0
-    return statistics.stdev(gaps) / mean
-
-
-def evaluate(now=None, timestamps=None):
-    """Return a decision dict. Pure given its inputs, so it is testable."""
-    now = now or datetime.now(timezone.utc)
-    ts = timestamps if timestamps is not None else _recent_timestamps()
-
-    in_1h = [t for t in ts if t >= now - timedelta(hours=1)]
-    in_24h = [t for t in ts if t >= now - timedelta(hours=24)]
-    in_72h = ts
-
-    counters = {
-        "count_1h": len(in_1h),
-        "count_24h": len(in_24h),
-        "count_72h": len(in_72h),
-        "max_1h": MAX_PER_1H,
-        "max_24h": MAX_PER_24H,
-        "max_72h": MAX_PER_72H,
-    }
-
-    def decision(action, rc, reason, wait_seconds=0, **extra):
-        d = {
-            "action": action,
-            "rc": rc,
-            "reason": reason,
-            "wait_seconds": int(wait_seconds),
-            "checked_at": now.isoformat(),
-        }
-        d.update(counters)
-        d.update(extra)
-        return d
-
-    # ---- hard ceilings first: these mean "stop", not "wait a bit" ----------
-    if len(in_24h) >= MAX_PER_24H:
-        return decision("stop", RC_STOP,
-                        f"24h cap reached ({len(in_24h)}/{MAX_PER_24H})")
-    if len(in_72h) >= MAX_PER_72H:
-        return decision("stop", RC_STOP,
-                        f"72h cap reached ({len(in_72h)}/{MAX_PER_72H})")
-
-    # ---- rolling hour: a wait, since it clears on its own ------------------
-    if len(in_1h) >= MAX_PER_1H:
-        oldest = min(in_1h)
-        wait = (oldest + timedelta(hours=1) - now).total_seconds()
-        return decision("wait", RC_WAIT,
-                        f"1h cap reached ({len(in_1h)}/{MAX_PER_1H})",
-                        max(wait, 60))
-
-    # ---- minimum gap ------------------------------------------------------
-    if ts:
-        since_last = (now - max(ts)).total_seconds()
-        if since_last < MIN_GAP_S:
-            return decision("wait", RC_WAIT,
-                            f"min gap not met ({int(since_last)}s < {MIN_GAP_S}s)",
-                            MIN_GAP_S - since_last,
-                            seconds_since_last=int(since_last))
-
-    # ---- cadence regularity -----------------------------------------------
-    # CRITICAL: both this rule and the spread rule below must be evaluated
-    # against the state that WOULD exist if we posted right now, never against
-    # history alone. History does not change while we wait, so a rule phrased
-    # over past gaps can never be satisfied by waiting: an earlier version of
-    # this file compared the last two gaps (120s, 120s -> CV 0.00), told the
-    # caller to sleep, and then returned the identical verdict forever. That
-    # livelocked the pipeline at 3 actions total and cost 1.3 actions/day
-    # instead of the intended ~25. Including the pending gap makes waiting
-    # monotonically increase CV, so the rule always resolves itself.
-    candidate_gap = (now - max(ts)).total_seconds() if ts else None
-    gaps = _gaps(ts)
-    if candidate_gap is not None:
-        gaps = gaps + [candidate_gap]
-    gaps = gaps[-CV_WINDOW:]
-    cv = _cv(gaps)
-    if cv is not None and cv < CV_FLOOR:
-        # Metronomic. Break it with a long randomized pause rather than the floor.
-        pause = random.uniform(CV_PAUSE_MIN_S, CV_PAUSE_MAX_S)
-        return decision("wait", RC_WAIT,
-                        f"cadence too regular (CV={cv:.2f} < {CV_FLOOR:.2f} "
-                        f"over last {len(gaps)} gaps incl. pending)",
-                        pause, cv=round(cv, 3))
-
-    # ---- daily spread: do not bunch the day's actions into one window ------
-    # Same "as if we posted now" framing: `now` is the effective end of the
-    # window, so the spread grows as we wait and the rule cannot livelock.
-    if len(in_24h) >= max(3, MAX_PER_24H // 2):
-        spread = (now - min(in_24h)).total_seconds()
-        if spread < MIN_SPREAD_S:
-            wait = MIN_SPREAD_S - spread
-            return decision("wait", RC_WAIT,
-                            f"daily spread too tight ({int(spread/60)}min over "
-                            f"{len(in_24h)} actions; want >= {MIN_SPREAD_S//3600}h)",
-                            wait, spread_minutes=int(spread / 60))
-
-    return decision("allow", RC_ALLOW, "within all pacing limits",
-                    cv=(round(cv, 3) if cv is not None else None))
-
-
-def main():
-    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
-    ap.add_argument("command", choices=["check", "status"])
-    ap.add_argument("--json", action="store_true",
-                    help="emit the full decision as JSON")
-    args = ap.parse_args()
-
-    try:
-        d = evaluate()
-    except Exception as exc:  # noqa: BLE001 - fail closed on ANY read failure
-        d = {
-            "action": "stop",
-            "rc": RC_STOP,
-            "reason": f"pacing state unreadable, failing closed: {exc}",
-            "wait_seconds": 0,
-        }
-
-    if args.command == "status":
-        print(json.dumps(d, indent=2))
-        return 0
-
-    if args.json:
-        print(json.dumps(d))
-    else:
-        print(f"{d['action'].upper()}: {d['reason']}"
-              + (f" (wait {d['wait_seconds']}s)" if d["wait_seconds"] else ""))
-    return d["rc"]
-
-
-if __name__ == "__main__":
-    sys.exit(main())