@m13v/s4l 1.7.4-rc.23 → 1.7.4-rc.25

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.4-rc.23",
-  "installedAt": "2026-07-12T19:50:52.791Z"
+  "version": "1.7.4-rc.25",
+  "installedAt": "2026-07-13T15:58:56.002Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.4-rc.23",
+  "version": "1.7.4-rc.25",
   "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.23",
+  "version": "1.7.4-rc.25",
   "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.23",
+  "version": "1.7.4-rc.25",
   "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/autopilot_stall_watch.py

@@ -59,6 +59,25 @@ RUNNING_STALL_SECONDS = 1200
 # At StartInterval 120 that is ~6 min of continuous stall.
 ALERT_AFTER = 3
 
+# --- Host-sleep awareness (2026-07-13, Sentry S4L-4B) ------------------------
+# launchd does NOT fire StartInterval jobs while the host is suspended, so the
+# wall-clock gap between consecutive ticks of THIS watchdog is a reliable sleep
+# detector: a gap of 3+ intervals means the box was asleep (or powered off),
+# not stalled. S4L-4B (Nhat's MacBook Air, 2026-07-11): laptop slept mid-cycle,
+# one producer enqueue timeout latched, no cycle ran to clear it, and the page
+# fired with pending=0/running=0 and a bogus "account change?" cause while the
+# telemetry showed 9 samples in a 2h window (40-min gaps). Laptops that sleep
+# between cycles would re-trigger that page forever.
+TICK_INTERVAL_SECONDS = 120  # keep in sync with launchd StartInterval
+SLEEP_GAP_SECONDS = TICK_INTERVAL_SECONDS * 3  # missed >=3 ticks -> host slept
+# For this long after a detected sleep gap, pre-existing latch/age signals are
+# treated as sleep-tainted: they must be corroborated by actual queued work
+# (pending/running > 0) or the outcome-level batches_stuck backstop to page.
+SLEEP_GAP_RECENT_SECONDS = 1800
+# A worker-task transcript modified this recently proves the routines are
+# firing, which rules out the "orphaned routines / account change" cause.
+WORKER_RECENT_SECONDS = 1800
+
 # A box counts as configured when ANY complete worker set has its SKILL.md on
 # disk: the universal type-blind worker, its short-lived staging predecessor, or
 # the legacy per-type pair. Keep in sync with WORKER_TASK_SETS in
@@ -142,6 +161,46 @@ def _recent_rate_limit(window: int = 1200) -> bool:
     return False
 
 
+def _worker_ran_recently(window: int = WORKER_RECENT_SECONDS) -> bool:
+    """True if any s4l-worker scheduled-task transcript was written in the last
+    `window` seconds — direct on-disk proof the worker routines are firing, so
+    a stall can NOT be the orphaned-routines / account-change shape. Same
+    transcript bucket _recent_rate_limit reads."""
+    try:
+        now = time.time()
+        for f in glob.glob(os.path.expanduser("~/.claude/projects/*s4l-worker*/*.jsonl")):
+            try:
+                if (now - os.path.getmtime(f)) <= window:
+                    return True
+            except OSError:
+                continue
+    except Exception:
+        pass
+    return False
+
+
+def _api_reachable(timeout: float = 3.0) -> bool:
+    """True if the S4L API host answers HTTP at all. ANY HTTP status counts as
+    reachable (a 4xx/5xx still proves the network path is up); only a socket /
+    URL error means offline. Used to hold the Sentry page while the box has no
+    network — an offline box is a different, self-healing condition, and the
+    page would be misleading (plus the event can't ship anyway). The stall
+    episode keeps counting, so if it's still stalled when connectivity returns,
+    the page fires then."""
+    import urllib.error
+    import urllib.request
+
+    base = os.environ.get("AUTOPOSTER_API_BASE", "https://s4l.ai").rstrip("/")
+    try:
+        req = urllib.request.Request(base, method="HEAD")
+        urllib.request.urlopen(req, timeout=timeout)
+        return True
+    except urllib.error.HTTPError:
+        return True  # server answered; network is up
+    except Exception:
+        return False
+
+
 BATCH_PROGRESSION_MIN_BATCHES = 5
 BATCH_PROGRESSED_PHASES = {"phase2b-gen", "phase2b-post"}
 
@@ -348,6 +407,30 @@ def _report_queue_health_sample(
 
 
 def main() -> int:
+    now = time.time()
+    st = _read_state()
+
+    # Sleep detection: launchd skips ticks while the host is suspended, so a
+    # wall-clock gap between this tick and the previous one of >= 3 intervals
+    # means the box slept (see the S4L-4B block by the constants above).
+    last_tick_at = st.get("last_tick_at")
+    last_sleep_gap_at = st.get("last_sleep_gap_at")
+    if last_tick_at is not None:
+        tick_gap = now - float(last_tick_at)
+        if tick_gap > SLEEP_GAP_SECONDS:
+            last_sleep_gap_at = now
+            sys.stderr.write(
+                f"[stall-watch] tick gap {int(tick_gap)}s (> {SLEEP_GAP_SECONDS}s) — "
+                "host was asleep/off; treating stall signals as sleep-tainted for "
+                f"{SLEEP_GAP_RECENT_SECONDS}s\n"
+            )
+    sleep_gap_recent = bool(
+        last_sleep_gap_at is not None
+        and (now - float(last_sleep_gap_at)) < SLEEP_GAP_RECENT_SECONDS
+    )
+
+    pending = _pending_count()
+    running = _running_count()
     age = _oldest_pending_age()
     run_age = _oldest_running_age()
     timeouts = _consecutive_timeouts()
@@ -362,8 +445,16 @@ def main() -> int:
     # never claimed), (3) running-age (job claimed then wedged mid-run) — (3) is
     # the only one of the first three that catches a worker dying after it picked
     # up the job — (4) batches_stuck, the outcome-level backstop above.
+    # Latch sanity gate (S4L-4B): consecutive_timeouts is durable and only
+    # clears on a successful drain, so ONE timed-out enqueue keeps a box
+    # looking stalled for as long as no cycle runs — even with a provably idle
+    # queue (pending=0, running=0). A single timeout only counts when there is
+    # actual queued work to corroborate it; an idle-queue latch needs >= 2.
+    # NOTE: deliberately stricter than the menubar/_index.ts stall HINT
+    # (timeouts >= 1) — a UI hint may over-trigger, a fleet page must not.
+    timeouts_signal = timeouts >= 2 or (timeouts >= 1 and (pending > 0 or running > 0))
     stalled = configured and (
-        timeouts >= 1
+        timeouts_signal
         or (age is not None and age > STALL_SECONDS)
         or (run_age is not None and run_age > RUNNING_STALL_SECONDS)
         or batches_stuck
@@ -373,13 +464,17 @@ def main() -> int:
     # episode resets and a LATER real stall (orphaned routines) still alerts.
     if stalled and _recent_rate_limit():
         stalled = False
+    # Sleep suppression: right after a wake, the latch (and any pre-nap ages)
+    # predate the sleep, not a worker failure. Require corroboration by real
+    # queued work or the outcome-level backstop before calling it a stall.
+    if stalled and sleep_gap_recent and not (pending > 0 or running > 0 or batches_stuck):
+        stalled = False
 
     # Record this tick regardless of outcome — see _report_queue_health_sample.
     _report_queue_health_sample(
-        _pending_count(), _running_count(), timeouts, age, run_age, stalled, batches_stuck
+        pending, running, timeouts, age, run_age, stalled, batches_stuck
     )
 
-    st = _read_state()
     consecutive = int(st.get("consecutive", 0))
     alerted = bool(st.get("alerted", False))
     # first_seen_at: first check this episode looked stalled at all (predates
@@ -390,6 +485,10 @@ def main() -> int:
     first_seen_at = st.get("first_seen_at")
     alerted_at = st.get("alerted_at")
 
+    # Tick bookkeeping persisted on EVERY exit path — the sleep detector needs
+    # an unbroken last_tick_at chain even (especially) while healthy.
+    tick_state = {"last_tick_at": now, "last_sleep_gap_at": last_sleep_gap_at}
+
     if not stalled:
         # Recovered (or never stalled) -> reset the episode so the next stall pages.
         if consecutive or alerted:
@@ -397,7 +496,7 @@ def main() -> int:
                 total_duration = time.time() - float(first_seen_at)
                 paged_duration = (time.time() - float(alerted_at)) if alerted_at else None
                 _report_recovery(total_duration, paged_duration)
-            _write_state({"consecutive": 0, "alerted": False})
+        _write_state({**tick_state, "consecutive": 0, "alerted": False})
         return 0
 
     consecutive += 1
@@ -411,60 +510,86 @@ def main() -> int:
     # the fallback is the classic orphaned-routine case.
     wedged_inflight = run_age is not None and run_age > RUNNING_STALL_SECONDS
     if consecutive >= ALERT_AFTER and not alerted:
-        try:
-            sentry = _sentry()
-            sentry.init()
-            if wedged_inflight:
-                cause = (
-                    "a worker claimed a draft job and then died mid-run (claude -p child "
-                    "never came up / crashed)"
-                )
-                stall_shape = "inflight_wedged"
-            elif batches_stuck:
-                cause = (
-                    f"last {BATCH_PROGRESSION_MIN_BATCHES} twitter_batches all failed to "
-                    "reach phase2b-gen — drafting is not actually happening even if the "
-                    "queue-level counters look ambiguous"
-                )
-                stall_shape = "batches_not_progressing"
-            else:
-                cause = "scheduled-task routines likely orphaned — Claude Desktop account change?"
-                stall_shape = "not_draining"
-            # Our own staging/QA/dev boxes (identity.is_internal_install) get set
-            # up and rebuilt with nobody actively feeding the queue, which looks
-            # identical to a real stall on the signals above. Downgrade those to
-            # warning instead of error so they don't page as a customer incident
-            # (the digest only scans error/fatal) while still leaving a Sentry
-            # record if we ever need to look one up by hand.
-            is_internal = identity.is_internal_install()
-            sentry.capture_message(
-                "social-autoposter autopilot stalled: draft jobs are not being "
-                f"drained ({cause}). producer consecutive timeouts={timeouts}, "
-                f"oldest pending job age={age_str}, oldest in-flight (running) job "
-                f"age={run_age_str}, sustained {consecutive} checks.",
-                level=("warning" if is_internal else "error"),
-                tags={
-                    "component": "autopilot",
-                    "issue": "stall",
-                    "stall_shape": stall_shape,
-                    "consecutive_timeouts": str(timeouts),
-                    "oldest_pending_age_s": str(int(age)) if age is not None else "",
-                    "oldest_running_age_s": str(int(run_age)) if run_age is not None else "",
-                    "batches_stuck": str(batches_stuck),
-                    "internal_install": str(is_internal),
-                },
-            )
-            sentry.flush()
-        except Exception:
-            # No Sentry (helper/SDK missing) -> at least leave a local breadcrumb.
+        if not _api_reachable():
+            # No network: an offline box is a different, self-healing condition,
+            # the page would misattribute it to the worker (and the event can't
+            # ship anyway). Keep the episode counting so a stall that survives
+            # the outage still pages the tick connectivity returns.
             sys.stderr.write(
-                f"[stall-watch] autopilot stalled (timeouts={timeouts}, "
-                f"pending_age={age_str}, running_age={run_age_str}) but Sentry report failed\n"
+                f"[stall-watch] stall persisted {consecutive} checks but the API is "
+                "unreachable (box offline?); deferring the page until network returns\n"
             )
-        alerted = True
-        alerted_at = time.time()
+        else:
+            try:
+                sentry = _sentry()
+                sentry.init()
+                if wedged_inflight:
+                    cause = (
+                        "a worker claimed a draft job and then died mid-run (claude -p child "
+                        "never came up / crashed)"
+                    )
+                    stall_shape = "inflight_wedged"
+                elif batches_stuck:
+                    cause = (
+                        f"last {BATCH_PROGRESSION_MIN_BATCHES} twitter_batches all failed to "
+                        "reach phase2b-gen — drafting is not actually happening even if the "
+                        "queue-level counters look ambiguous"
+                    )
+                    stall_shape = "batches_not_progressing"
+                elif _worker_ran_recently():
+                    # On-disk transcripts prove the worker routines ARE firing, so
+                    # this cannot be the orphaned-routines shape (S4L-4B paged with
+                    # exactly that bogus cause while the registry sample showed the
+                    # task had run seconds earlier).
+                    cause = (
+                        "producer timeout latch, but worker-task transcripts show recent "
+                        "runs — routines are firing; suspect a transient enqueue timeout"
+                        + (" or a host sleep gap" if sleep_gap_recent else "")
+                        + ", NOT orphaned routines"
+                    )
+                    stall_shape = "latch_worker_alive"
+                else:
+                    cause = "scheduled-task routines likely orphaned — Claude Desktop account change?"
+                    stall_shape = "not_draining"
+                # Our own staging/QA/dev boxes (identity.is_internal_install) get set
+                # up and rebuilt with nobody actively feeding the queue, which looks
+                # identical to a real stall on the signals above. Downgrade those to
+                # warning instead of error so they don't page as a customer incident
+                # (the digest only scans error/fatal) while still leaving a Sentry
+                # record if we ever need to look one up by hand.
+                is_internal = identity.is_internal_install()
+                sentry.capture_message(
+                    "social-autoposter autopilot stalled: draft jobs are not being "
+                    f"drained ({cause}). producer consecutive timeouts={timeouts}, "
+                    f"oldest pending job age={age_str}, oldest in-flight (running) job "
+                    f"age={run_age_str}, sustained {consecutive} checks.",
+                    level=("warning" if is_internal else "error"),
+                    tags={
+                        "component": "autopilot",
+                        "issue": "stall",
+                        "stall_shape": stall_shape,
+                        "consecutive_timeouts": str(timeouts),
+                        "oldest_pending_age_s": str(int(age)) if age is not None else "",
+                        "oldest_running_age_s": str(int(run_age)) if run_age is not None else "",
+                        "batches_stuck": str(batches_stuck),
+                        "internal_install": str(is_internal),
+                        "pending": str(pending),
+                        "running": str(running),
+                        "recent_sleep_gap": str(sleep_gap_recent),
+                    },
+                )
+                sentry.flush()
+            except Exception:
+                # No Sentry (helper/SDK missing) -> at least leave a local breadcrumb.
+                sys.stderr.write(
+                    f"[stall-watch] autopilot stalled (timeouts={timeouts}, "
+                    f"pending_age={age_str}, running_age={run_age_str}) but Sentry report failed\n"
+                )
+            alerted = True
+            alerted_at = time.time()
 
     _write_state({
+        **tick_state,
         "consecutive": consecutive,
         "alerted": alerted,
         "first_seen_at": first_seen_at,

package/scripts/cdp_ready_check.py

@@ -33,7 +33,12 @@ def main() -> int:
     except Exception:
         import urllib.request
         try:
-            urllib.request.urlopen(f"{url}/json/version", timeout=3)
+            # ProxyHandler({}): loopback CDP must never route through a proxy.
+            # macOS system proxy settings leak into urllib's default opener, and
+            # a box-wide forwarder 403s 127.0.0.1 probes (2026-07-13 root cause
+            # of the "wedged Chrome" misdiagnosis).
+            opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+            opener.open(f"{url}/json/version", timeout=3)
             print(json.dumps({"ready": True, "mode": "http-only"}))
             return 0
         except Exception as e:

package/skill/lock.sh

@@ -132,7 +132,31 @@ if [ -z "${_SA_LOCK_DIRS+x}" ]; then
       rm -f "$t"
     done
   }
-  trap _sa_release_locks EXIT INT TERM HUP
+  trap _sa_release_locks EXIT
+  # 2026-07-12: INT/TERM/HUP release locks AND EXIT, instead of sharing the
+  # plain EXIT handler. Scenario this fixes (observed 2026-07-12 12:02:09,
+  # engage-dm-replies.sh pid 72465): a stray signal fired the old combined
+  # trap, which released BOTH held locks and then RESUMED the script (bash
+  # continues after a trapped signal when the handler doesn't exit). The run
+  # kept driving the shared twitter Chrome without its twitter-browser lock,
+  # the twitter cycle legitimately acquired the freed lock and navigated the
+  # same tab mid-send, and all 3 send-dm attempts died with
+  # thread_url_redirected ("shared-tab drift", human_dm_replies id 100045).
+  # A signaled run must never continue lock-protected work: log WHICH signal
+  # hit (the old single-line event gave no clue), clean up once, exit 128+N.
+  # Scripts that install their own combined traps after sourcing this file
+  # (e.g. run-twitter-cycle.sh's _sa_combined_exit) still override these.
+  _sa_exit_on_signal() {
+    local _sig="$1" _code="$2"
+    _sa_lock_event signal_exit "-" "signal=$_sig"
+    echo "[lock] caught SIG${_sig} pid=$$; releasing locks and exiting $_code at $(date +%H:%M:%S)" >&2
+    _sa_release_locks
+    trap - EXIT
+    exit "$_code"
+  }
+  trap '_sa_exit_on_signal INT 130' INT
+  trap '_sa_exit_on_signal TERM 143' TERM
+  trap '_sa_exit_on_signal HUP 129' HUP
 fi
 
 acquire_lock() {