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

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.2",
+  "installedAt": "2026-07-30T22:16:14.950Z"
 }

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.2",
   "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.2",
   "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.2",
   "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_pacing.py

@@ -78,6 +78,7 @@ existing "db_unavailable -> script already fails closed" rule in run-linkedin.sh
 
 import argparse
 import json
+import math
 import os
 import random
 import statistics
@@ -103,6 +104,26 @@ def _envi(name, default):
         return default
 
 
+# --- interval GENERATION (not just a ceiling) ------------------------------
+# A pure floor+ceiling cap produces a clipped, bimodal shape: run flat out at
+# the floor until the hourly ceiling bites, then stall. Measured on the first
+# version of this file: 59% of all gaps sat exactly at the 120s floor and NOTHING
+# landed in the 3-10 minute band. That is a sharper machine signature than the
+# unpaced behaviour it replaced, so the floor alone is not pacing.
+#
+# Instead we model arrivals as a POISSON PROCESS: each gap is drawn from an
+# exponential distribution whose mean is set so the daily budget spreads across
+# the active window. Exponential arrivals are memoryless, naturally varied
+# (CV ~= 1.0 by construction), and produce no pile-up at any particular value.
+# MIN_GAP_S survives only as a clamp for the short tail.
+#
+# The draw is DETERMINISTIC in the timestamp of the previous action. This is
+# essential: the gate gets polled repeatedly while waiting, and a fresh random
+# draw per call would let the caller "reroll until lucky", collapsing the whole
+# distribution back onto the floor.
+ACTIVE_START_H = _envi("LI_PACE_ACTIVE_START_H", 8)    # local hour, inclusive
+ACTIVE_END_H   = _envi("LI_PACE_ACTIVE_END_H", 22)     # local hour, exclusive
+MAX_GAP_S      = _envi("LI_PACE_MAX_GAP_S", 4 * 3600)
 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)
@@ -172,6 +193,50 @@ def _recent_timestamps(hours=72):
         conn.close()
 
 
+def _active_seconds_per_day():
+    span = (ACTIVE_END_H - ACTIVE_START_H) % 24
+    return (span or 24) * 3600
+
+
+def _in_active_window(dt_local):
+    h = dt_local.hour
+    if ACTIVE_START_H == ACTIVE_END_H:
+        return True
+    if ACTIVE_START_H < ACTIVE_END_H:
+        return ACTIVE_START_H <= h < ACTIVE_END_H
+    return h >= ACTIVE_START_H or h < ACTIVE_END_H  # window wraps midnight
+
+
+def _seconds_to_window_open(dt_local):
+    """Seconds until the active window next opens. 0 if already open."""
+    if _in_active_window(dt_local):
+        return 0
+    nxt = dt_local.replace(hour=ACTIVE_START_H, minute=0, second=0, microsecond=0)
+    if nxt <= dt_local:
+        nxt += timedelta(days=1)
+    return (nxt - dt_local).total_seconds()
+
+
+def _target_gap(last_ts):
+    """Exponentially-distributed target gap, deterministic in `last_ts`.
+
+    mean = active_seconds_per_day / MAX_PER_24H, so a full day's budget spreads
+    naturally across the active window instead of bunching at a floor.
+
+    Determinism matters: see the CONFIG note. Same last_ts always yields the
+    same target, so polling cannot reroll its way down to MIN_GAP_S.
+    """
+    import hashlib
+
+    mean = _active_seconds_per_day() / max(MAX_PER_24H, 1)
+    digest = hashlib.sha256(last_ts.isoformat().encode("utf-8")).digest()
+    # 53 bits -> uniform in [0,1); nudged off the endpoints for the log below.
+    u = int.from_bytes(digest[:7], "big") / float(1 << 56)
+    u = min(max(u, 1e-9), 1 - 1e-9)
+    gap = -mean * math.log(1.0 - u)  # inverse-CDF of Exponential(1/mean)
+    return max(MIN_GAP_S, min(gap, MAX_GAP_S))
+
+
 def _gaps(ts):
     return [
         (b - a).total_seconds()
@@ -236,14 +301,31 @@ def evaluate(now=None, timestamps=None):
                         f"1h cap reached ({len(in_1h)}/{MAX_PER_1H})",
                         max(wait, 60))
 
-    # ---- minimum gap ------------------------------------------------------
+    # ---- active-hours window ----------------------------------------------
+    # Humans do not comment uniformly around the clock. Observed spans were
+    # 20-24h/day, which is itself a tell independent of volume.
+    now_local = now.astimezone()
+    to_open = _seconds_to_window_open(now_local)
+    if to_open > 0:
+        return decision("wait", RC_WAIT,
+                        f"outside active window "
+                        f"{ACTIVE_START_H:02d}:00-{ACTIVE_END_H:02d}:00 local",
+                        to_open)
+
+    # ---- sampled inter-action interval (the actual pacing) ----------------
+    # Not a flat floor: a per-gap draw from an exponential, so the resulting
+    # distribution is continuous instead of piling up at a single value.
     if ts:
-        since_last = (now - max(ts)).total_seconds()
-        if since_last < MIN_GAP_S:
+        last = max(ts)
+        since_last = (now - last).total_seconds()
+        target = _target_gap(last)
+        if since_last < target:
             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))
+                            f"sampled interval not elapsed "
+                            f"({int(since_last)}s < {int(target)}s target)",
+                            target - since_last,
+                            seconds_since_last=int(since_last),
+                            target_gap_s=int(target))
 
     # ---- cadence regularity -----------------------------------------------
     # CRITICAL: both this rule and the spread rule below must be evaluated

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

@@ -292,10 +292,22 @@ PENDING_COUNT=$(li_reply_count pending)
 # 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)"
+_LI_PACE_JSON="$("$PY_BIN" "$REPO_DIR/scripts/linkedin_pacing.py" check --json 2>&1)" || _LI_PACE_RC=$?
+_LI_PACE_WAIT=$(printf '%s' "$_LI_PACE_JSON" | "$PY_BIN" -c \
+    'import json,sys
+try: print(int(json.load(sys.stdin).get("wait_seconds", 0)))
+except Exception: print(0)' 2>/dev/null || echo 0)
+log "PACING: $_LI_PACE_JSON"
+
+# Skip Phase B when a ceiling is blown (rc=78) OR when the next slot is far off
+# (rc=75 with a long wait). The long-wait case is mostly the overnight
+# active-hours window: without this we would spin up a full Claude session that
+# is forbidden from posting anything for the next several hours. Short waits
+# (< 15 min) still enter the phase, since drafting takes time anyway and the
+# per-reply Step 3b gate can sleep the small remainder.
+if [ "$PENDING_COUNT" -ne 0 ] && { [ "$_LI_PACE_RC" -eq 78 ] || \
+     { [ "$_LI_PACE_RC" -eq 75 ] && [ "${_LI_PACE_WAIT:-0}" -gt 900 ]; }; }; then
+    log "PACING: not postable now (rc=$_LI_PACE_RC, next slot in ${_LI_PACE_WAIT}s); skipping Phase B ($PENDING_COUNT rows stay pending)"
     PENDING_COUNT=0
     LI_PACED_OUT=1
 fi

package/skill/run-linkedin.sh

@@ -106,6 +106,30 @@ export SA_CYCLE_ID="$BATCH_ID"
 
 echo "=== LinkedIn Post Run: $(date) (batch=$BATCH_ID) ===" | tee "$LOG_FILE"
 
+# ---- PACING GATE (2026-07-30) --------------------------------------------
+# This pipeline is the LARGER of the two LinkedIn write paths: it logged 67-74
+# actions/day via log_post.py in the week before the 2026-07-20 session kill,
+# against ~23/day from engage-linkedin.sh. Gating only that other script would
+# have left ~75% of our LinkedIn footprint unpaced.
+#
+# Placed BEFORE Phase A on purpose. Phase B posts exactly ONE comment per fire,
+# so a single per-run check is sufficient, and bailing here also skips Phase A
+# discovery (~$10-15 of Claude spend) rather than paying for candidates we are
+# not allowed to act on.
+#
+# Any non-allow verdict skips the fire outright: this job is on a 15-minute
+# launchd cadence, so the next fire re-checks shortly. We deliberately do not
+# sleep inside the run and hold the browser lock while waiting.
+if [ "$LINKEDIN_BACKEND" = "browser" ]; then
+    _LI_PACE_RC=0
+    _LI_PACE_OUT="$(python3 "$REPO_DIR/scripts/linkedin_pacing.py" check 2>&1)" || _LI_PACE_RC=$?
+    echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] PACING: $_LI_PACE_OUT" | tee -a "$LOG_FILE"
+    if [ "$_LI_PACE_RC" -ne 0 ]; then
+        echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] PACING: skipping this fire (rc=$_LI_PACE_RC); next fire re-checks in ~15min" | tee -a "$LOG_FILE"
+        exit 0
+    fi
+fi
+
 # 2026-05-01: lock policy was changed from "hold for the entire run" to
 # "hold only while a Claude phase is actively driving the browser". The old
 # policy meant a single 25-45min cycle held linkedin-browser exclusively for