@m13v/s4l 1.7.4-rc.14 → 1.7.4-rc.16

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.4-rc.14",
-  "installedAt": "2026-07-11T04:13:18.650Z"
+  "version": "1.7.4-rc.16",
+  "installedAt": "2026-07-11T18:28:11.012Z"
 }

package/mcp/manifest.json

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

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""LinkedIn posting cadence: 4 active days, then a mandatory 2-day break.
+
+Per user instruction (2026-07-11): LinkedIn activity should not run more than
+four days at a time before taking a two-day break. "Active day" is counted
+only when real posting/engagement activity actually happened that day (an
+outage day does not count toward the four), and the break pauses ALL LinkedIn
+traffic, including the passive presence-check job, not just posting.
+
+Every LinkedIn entrypoint (skill/run-linkedin.sh, engage-linkedin.sh,
+engage-dm-replies.sh, dm-outreach-linkedin.sh, audit-linkedin.sh,
+linkedin-presence.sh) already gates on the existence of ONE file:
+    ~/.claude/social-autoposter/linkedin.killswitch
+That file is scripts/linkedin_killswitch.py's antibot killswitch. This module
+reuses the SAME file for a scheduled break (signal="scheduled_break") so every
+entrypoint pauses automatically, with zero edits to the locked entrypoint
+scripts. It never overwrites a REAL antibot signal, and linkedin_killswitch.py
+is patched (recover-check) to never try to auto-recover a scheduled_break.
+
+State lives at ~/.claude/social-autoposter/linkedin_cadence.json:
+    {
+      "phase": "active" | "break",
+      "phase_started": "2026-07-11T20:00:00Z",
+      "active_days": ["2026-07-13", "2026-07-14", ...]   # UTC dates with
+                                                          # confirmed posts,
+                                                          # only meaningful
+                                                          # while phase=active
+    }
+
+CLI:
+    python3 scripts/linkedin_cadence.py enforce   # one tick; called every 15m
+    python3 scripts/linkedin_cadence.py status    # print state (json)
+"""
+
+import json
+import os
+import sys
+from datetime import datetime, timedelta, timezone
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import http_api  # noqa: E402
+import linkedin_killswitch as ks  # noqa: E402
+
+STATE_DIR = os.path.expanduser(
+    os.environ.get("LINKEDIN_KILLSWITCH_DIR", "~/.claude/social-autoposter")
+)
+STATE_FILE = os.path.expanduser(
+    os.environ.get("LINKEDIN_CADENCE_FILE", os.path.join(STATE_DIR, "linkedin_cadence.json"))
+)
+
+ACTIVE_DAYS_TARGET = int(os.environ.get("LINKEDIN_CADENCE_ACTIVE_DAYS", "4"))
+BREAK_DAYS = int(os.environ.get("LINKEDIN_CADENCE_BREAK_DAYS", "2"))
+
+SCHEDULED_BREAK_SIGNAL = "scheduled_break"
+
+
+def _now():
+    return datetime.now(timezone.utc)
+
+
+def _now_iso():
+    return _now().strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _today_str():
+    return _now().date().isoformat()
+
+
+def _parse_ts(ts):
+    return datetime.strptime(ts, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
+
+
+def _ensure_dir():
+    os.makedirs(STATE_DIR, exist_ok=True)
+
+
+def load_state():
+    try:
+        with open(STATE_FILE, "r") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def save_state(state):
+    _ensure_dir()
+    tmp = STATE_FILE + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(state, f, indent=2)
+        f.write("\n")
+    os.replace(tmp, STATE_FILE)
+
+
+def _default_state_starting_break():
+    # First-ever run: user asked to start immediately with a two-day break.
+    return {"phase": "break", "phase_started": _now_iso(), "active_days": []}
+
+
+def _today_post_count():
+    """LinkedIn posts made today (UTC), via the same API the dashboard uses.
+
+    Best-effort: returns None on any failure so callers can skip counting
+    this tick rather than wrongly recording 0 activity."""
+    try:
+        resp = http_api.api_get(
+            "/api/v1/dashboard/posts-per-day", {"days": 1, "platform": "linkedin"}
+        )
+        rows = (resp or {}).get("data", {}).get("rows", [])
+        today = _today_str()
+        for row in rows:
+            if row.get("day") == today:
+                return int(row.get("posts_made") or 0)
+        return 0
+    except Exception as exc:
+        print(f"[linkedin_cadence] WARN: posts-per-day query failed: {exc}", file=sys.stderr)
+        return None
+
+
+def _pause_marker_set():
+    """Set the shared killswitch file for a scheduled break, unless a REAL
+    antibot signal is already in charge (never stomp a genuine block)."""
+    payload = ks.read()
+    if payload is None:
+        ks.engage(
+            signal=SCHEDULED_BREAK_SIGNAL,
+            detail="cadence: scheduled 2-day pause after 4 active days",
+            send_email=False,
+        )
+        print("[linkedin_cadence] pause marker set (scheduled_break)", file=sys.stderr)
+    elif payload.get("signal") == SCHEDULED_BREAK_SIGNAL:
+        pass  # already set by us; idempotent, no trail spam
+    else:
+        print(
+            f"[linkedin_cadence] real killswitch already active (signal="
+            f"{payload.get('signal')!r}); deferring to it, not overwriting",
+            file=sys.stderr,
+        )
+
+
+def _pause_marker_clear_if_ours():
+    payload = ks.read()
+    if payload is not None and payload.get("signal") == SCHEDULED_BREAK_SIGNAL:
+        ks.clear()
+        print("[linkedin_cadence] pause marker cleared (break ended)", file=sys.stderr)
+
+
+def enforce():
+    state = load_state() or _default_state_starting_break()
+    if load_state() is None:
+        save_state(state)
+        print(
+            f"[linkedin_cadence] no prior state; starting BREAK phase now "
+            f"({BREAK_DAYS}d)",
+            file=sys.stderr,
+        )
+
+    now = _now()
+    phase = state["phase"]
+
+    if phase == "break":
+        started = _parse_ts(state["phase_started"])
+        elapsed = now - started
+        if elapsed >= timedelta(days=BREAK_DAYS):
+            state = {"phase": "active", "phase_started": _now_iso(), "active_days": []}
+            save_state(state)
+            _pause_marker_clear_if_ours()
+            print(
+                f"[linkedin_cadence] break ended after {elapsed}; switching to ACTIVE",
+                file=sys.stderr,
+            )
+            phase = "active"
+        else:
+            remaining = timedelta(days=BREAK_DAYS) - elapsed
+            _pause_marker_set()
+            print(
+                f"[linkedin_cadence] BREAK phase: {remaining} remaining",
+                file=sys.stderr,
+            )
+            return
+
+    # phase == "active"
+    real_block = ks.read()
+    if real_block is not None and real_block.get("signal") != SCHEDULED_BREAK_SIGNAL:
+        print(
+            f"[linkedin_cadence] account down for a real reason (signal="
+            f"{real_block.get('signal')!r}); not counting today, not pausing",
+            file=sys.stderr,
+        )
+        return
+
+    count = _today_post_count()
+    today = _today_str()
+    if count is not None and count > 0 and today not in state["active_days"]:
+        state["active_days"].append(today)
+        save_state(state)
+        print(
+            f"[linkedin_cadence] activity confirmed today ({count} posts); "
+            f"active_days={len(state['active_days'])}/{ACTIVE_DAYS_TARGET} "
+            f"{state['active_days']}",
+            file=sys.stderr,
+        )
+
+    if len(state["active_days"]) >= ACTIVE_DAYS_TARGET:
+        state = {"phase": "break", "phase_started": _now_iso(), "active_days": []}
+        save_state(state)
+        _pause_marker_set()
+        print(
+            f"[linkedin_cadence] {ACTIVE_DAYS_TARGET} active days reached; "
+            f"switching to BREAK for {BREAK_DAYS}d",
+            file=sys.stderr,
+        )
+    else:
+        print(
+            f"[linkedin_cadence] ACTIVE phase: "
+            f"{len(state['active_days'])}/{ACTIVE_DAYS_TARGET} active days so far",
+            file=sys.stderr,
+        )
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] not in ("enforce", "status"):
+        print("usage: linkedin_cadence.py [enforce|status]", file=sys.stderr)
+        sys.exit(2)
+    if sys.argv[1] == "status":
+        state = load_state()
+        print(json.dumps(state if state is not None else {"phase": None}, indent=2))
+        sys.exit(0)
+    enforce()
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/linkedin_killswitch.py

@@ -145,6 +145,10 @@ VALID_SIGNALS = {
     "session_invalid_marker",
     "captcha_detected",
     "manual",
+    # Deliberate pause from scripts/linkedin_cadence.py (4-active-days /
+    # 2-day-break schedule). Not an incident: recover-check must never try to
+    # auto-recover it, and engage() should never email on it.
+    "scheduled_break",
 }
 
 
@@ -894,6 +898,14 @@ def _cmd_recover_check(args):
     if not is_active():
         print("recover-check: killswitch not active, nothing to recover", file=sys.stderr)
         sys.exit(1)
+    payload = read() or {}
+    if payload.get("signal") == "scheduled_break":
+        print(
+            "recover-check: scheduled_break active (cadence pause, not a real "
+            "incident); deferring to scripts/linkedin_cadence.py, not probing",
+            file=sys.stderr,
+        )
+        sys.exit(1)
     if is_terminal():
         print(
             "recover-check: TERMINAL (auto-recovery gave up); "

package/skill/linkedin-cadence.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# linkedin-cadence.sh — enforce the 4-active-day / 2-day-break LinkedIn
+# posting schedule (user instruction, 2026-07-11). Fired every 15 minutes by
+# launchd (com.m13v.social-linkedin-cadence). All logic lives in
+# scripts/linkedin_cadence.py; this wrapper just logs the tick.
+
+set -uo pipefail
+export PATH="/opt/homebrew/bin:$PATH"
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+LOG="$LOG_DIR/linkedin-cadence.log"
+
+log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG" >&2; }
+
+PY="/opt/homebrew/bin/python3"
+[ -x "$PY" ] || PY="/usr/bin/python3"
+
+"$PY" "$REPO_DIR/scripts/linkedin_cadence.py" enforce >>"$LOG" 2>&1

package/skill/run-twitter-cycle.sh

@@ -2208,6 +2208,27 @@ CRITICAL:
 # installs) treats --allowedTools as a one-value flag, so a space-separated second
 # tool would leak in as the prompt. On the box these flags ride through
 # claude_job.py; Desktop's own web search + the reworded prompt enable it there.
+# --- Prep-prompt snapshot (2026-07-11) ---------------------------------------
+# Persist the exact rendered PREP_PROMPT per batch so prompt-block presence is
+# verifiable after any release (grep the file), instead of reverse-engineering
+# it from package scripts. The queue's prompt-*.md files are transient work
+# files deleted on completion, and the generation trace deliberately carries
+# only the exemplar context, so this is the ONLY durable full-prompt record.
+# Local-only, newest 50 kept (file cleanup, not candidate-row retention; the
+# no-retention rule covers DB *_candidates rows). Never blocks the run.
+PREP_PROMPT_DIR="${S4L_STATE_DIR:-$HOME/.social-autoposter-mcp}/prep-prompts"
+if mkdir -p "$PREP_PROMPT_DIR" 2>/dev/null; then
+    _PP_FILE="$PREP_PROMPT_DIR/prep-prompt-$BATCH_ID.md"
+    if printf '%s' "$PREP_PROMPT" > "$_PP_FILE" 2>/dev/null; then
+        ls -t "$PREP_PROMPT_DIR"/prep-prompt-*.md 2>/dev/null | tail -n +51 | while IFS= read -r _pp_old; do
+            rm -f "$_pp_old"
+        done
+        log "[prep_prompt_snapshot] batch=$BATCH_ID bytes=$(wc -c < "$_PP_FILE" | tr -d ' ') path=$_PP_FILE"
+    else
+        log "WARN: prep-prompt snapshot write failed for batch=$BATCH_ID (non-fatal)"
+    fi
+fi
+
 PREP_OUTPUT=$(printf '%s' "$PREP_PROMPT" | "$REPO_DIR/scripts/run_claude.sh" "run-twitter-cycle-prep" --strict-mcp-config --mcp-config "$TW_MCP_CONFIG" --allowedTools WebSearch,WebFetch -p --output-format json --json-schema "$PREP_SCHEMA" 2>&1)
 
 echo "$PREP_OUTPUT" >> "$LOG_FILE"