social-autoposter 1.6.154 → 1.6.156

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.154",
-  "installedAt": "2026-06-29T23:14:44.360Z"
+  "version": "1.6.156",
+  "installedAt": "2026-06-29T23:25:31.893Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.154",
+  "version": "1.6.156",
   "description": "Draft, review, approve, and autopilot X/Twitter posts.",
   "long_description": "The disclaimer above is generic Claude boilerplate. S4L 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 end to end**\n\n2\\. Quit fully with CMD+Q, restart Claude, and paste the prompt into a new chat.",
   "author": {

package/mcp/menubar/s4l_state.py

@@ -22,6 +22,7 @@ import os
 import subprocess
 import sys
 import threading
+import time
 import urllib.request
 from pathlib import Path
 
@@ -195,32 +196,58 @@ def loopback_tool(name: str, args=None, timeout: float = 20.0):
 
 
 # ---- the snapshot the menu bar renders ------------------------------------
-def snapshot():
-    """Full snapshot computed DIRECTLY from the stateful files via
-    scripts/snapshot.py — the SAME single-source module the MCP shells out to, so
-    the two surfaces can't diverge. The menu bar no longer depends on the MCP /
-    Claude being up: there is NO loopback call here, so a restarting or closed
-    Claude can't freeze or stale the menu (the old tier-1 `loopback_tool` blocked
-    the UI thread up to 20s and was the freeze).
-
-    Three tiers, in order:
-      1. LIVE — compute locally from the files (zero MCP dependency).
-      2. SUMMARY — the server's last persisted `status-summary.json`, if the local
-         compute somehow failed.
-      3. LEDGER — nothing else available: derive the essentials from the onboarding
-         ledger so progress still shows."""
+# Background snapshot cache. scripts/snapshot.py reads files but may spawn the
+# X-status subprocess (setup_twitter_auth.py -> CDP to Chrome), which must NEVER
+# run on the menu bar's UI thread — a hung Chrome would freeze the menu. So a
+# daemon thread recomputes and snapshot() returns the last cached value INSTANTLY.
+_snap_cache = {"val": None, "at": 0.0}
+_snap_lock = threading.Lock()
+_snap_refreshing = [False]
+
+
+def _compute_snapshot_full():
+    repo = os.environ.get("SAPS_REPO_DIR") or str(Path.home() / "social-autoposter")
+    scripts = os.path.join(repo, "scripts")
+    if scripts not in sys.path:
+        sys.path.insert(0, scripts)
+    import snapshot as _snapshot_mod  # scripts/snapshot.py
+    return _snapshot_mod.compute()
+
+
+def _refresh_snapshot_bg():
     try:
-        repo = os.environ.get("SAPS_REPO_DIR") or str(Path.home() / "social-autoposter")
-        scripts = os.path.join(repo, "scripts")
-        if scripts not in sys.path:
-            sys.path.insert(0, scripts)
-        import snapshot as _snapshot_mod  # scripts/snapshot.py
-        snap = _snapshot_mod.compute()
+        snap = _compute_snapshot_full()
         if isinstance(snap, dict) and "projects_total" in snap:
-            snap["_live"] = True
-            return snap
+            with _snap_lock:
+                _snap_cache["val"] = snap
+                _snap_cache["at"] = time.time()
     except Exception:
         pass
+    finally:
+        _snap_refreshing[0] = False
+
+
+def snapshot():
+    """Full snapshot computed DIRECTLY from the stateful files via
+    scripts/snapshot.py — the SAME single-source module the MCP shells out to, so
+    the two surfaces can't diverge. NO loopback / MCP dependency, so a restarting
+    or closed Claude can't freeze or stale the menu (the old tier-1 `loopback_tool`
+    blocked the UI thread up to 20s and was the freeze). The heavy compute runs on
+    a BACKGROUND thread; this returns the last cached result instantly.
+
+    Tiers: (1) the background-computed local snapshot; (2) the server's last
+    persisted `status-summary.json`; (3) the onboarding ledger."""
+    now = time.time()
+    with _snap_lock:
+        cached = _snap_cache["val"]
+        age = now - _snap_cache["at"]
+    if (cached is None or age > 4.0) and not _snap_refreshing[0]:
+        _snap_refreshing[0] = True
+        threading.Thread(target=_refresh_snapshot_bg, daemon=True).start()
+    if cached is not None:
+        out = dict(cached)
+        out["_live"] = True
+        return out
     summ = read_json("status-summary.json")
     if isinstance(summ, dict) and "projects_total" in summ:
         summ["_live"] = False

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "1.6.154",
+  "version": "1.6.156",
   "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": "social-autoposter",
-  "version": "1.6.154",
+  "version": "1.6.156",
   "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/reap_stale_claude_sessions.py

@@ -249,14 +249,29 @@ def main() -> int:
     dry = "--dry-run" in sys.argv
     max_age = _env_int("SAPS_REAPER_MAX_AGE_SEC", DEFAULT_MAX_AGE_SEC)
     # (1) Queue-correlated reaping knobs.
-    # grace: how long an UNCLAIMED session may live before it's reapable. Raised
-    # 90 -> 300 on 2026-06-29: at 90s the reaper was SIGTERMing actively-DRAFTING
-    # worker sessions (a draft legitimately runs minutes), which presented as the
-    # mysterious "~120s code-143 kill". Claim-holders are now spared outright via
-    # running_claim_pids() regardless of grace, so this only governs idle/leaked
-    # sessions; 5 min is a comfortable backstop for them and the count-cap still
-    # bounds memory if the queue signal is ever wrong.
-    grace = _env_int("SAPS_REAPER_GRACE_SEC", 300)  # idle/leaked-session backstop
+    # grace: how long an UNCLAIMED session may live before its AGE makes it reapable.
+    #
+    # 2026-06-29, second pass: this used to default to 90s, and the queue-readable
+    # branch below used it as the ONLY age gate -- which meant a separate, short,
+    # activity-BLIND timer governed normal operation and silently overrode the 35-min
+    # `max_age` ceiling that the whole top-of-file rationale is built around (producer
+    # deadline 1800s + margin). An actively-DRAFTING session ages out of the
+    # "inflight+margin newest" window after ~2 min as fresh empty workers spawn on top
+    # of it, then got SIGTERMed at 90s mid-draft -> the mysterious "~120s code-143
+    # kill". Raising it to 300s only moved the cliff.
+    #
+    # The fix is to stop having two timers. There is now ONE overall age ceiling
+    # (`max_age`, 35 min = producer deadline + margin): past it the producer has
+    # already discarded the worker's result, so the session is provably useless and
+    # safe to reap whether or not it ever claimed. `grace` therefore defaults to
+    # `max_age` -- the queue-readable branch is no longer allowed to preempt a session
+    # earlier than the producer's own deadline. What keeps MEMORY bounded instead of a
+    # short timer is (a) claim-holders are spared outright via running_claim_pids() and
+    # (b) the count-cap (max_group) reaps the oldest-beyond-N by COUNT, regardless of
+    # age, and never touches a claim-holder. Override only to deliberately re-introduce
+    # an earlier age gate (not recommended); it can never exceed max_age in effect.
+    grace = _env_int("SAPS_REAPER_GRACE_SEC", DEFAULT_MAX_AGE_SEC)  # = max_age: one ceiling
+    grace = min(grace, max_age)  # an override may only shorten, never outlive the ceiling
     keep_margin = _env_int("SAPS_REAPER_KEEP_MARGIN", 1)  # extra newest spared beyond busy set
     # (2) Count-cap backstop: never let one uuid group hold more than this many live
     # workers, regardless of queue state. 0 disables. The default rarely fires once

package/skill/run-draft-and-publish.sh

@@ -21,15 +21,32 @@ HB_PID=""  # scan-phase heartbeat (started below); torn down by the EXIT trap
 # the cycle's exit code.
 trap 'kill "$HB_PID" 2>/dev/null || true; rm -f "$OUT"; "$PY" "$REPO_DIR/scripts/saps_activity.py" clear 2>/dev/null || true' EXIT
 
-# Narrate the scan phase. The CDP scan runs inside the (locked) run-twitter-cycle.sh
-# which has no activity writer; this covers that window until the queue provider
-# flips the label to "finding threads"/"drafting replies" on its first claude call.
+# Narrate the scan phase, GRANULARLY. The CDP scan runs inside the (locked)
+# run-twitter-cycle.sh which has no activity writer; this covers that window until
+# the queue provider flips the label to "finding threads"/"drafting replies".
+# Instead of a frozen "scanning X for threads" for the whole multi-minute scan,
+# each heartbeat recomputes elapsed and scrapes THIS cycle's own stdout ($OUT, the
+# tee target below) for live progress — queries run, and candidates found once
+# Phase 1 reports them — so the menu bar actually moves. Reads $OUT only; never
+# touches the locked cycle. heartbeat() re-stamps ONLY while the state is still
+# "scanning", so once the provider advances the phase it goes quiet (no flicker).
 "$PY" "$REPO_DIR/scripts/saps_activity.py" write scanning "scanning X for threads" 2>/dev/null || true
-# Keep "scanning" fresh against the menu bar's staleness TTL for the whole scan
-# (which can run minutes with no other writer). The heartbeat re-stamps ONLY while
-# the state is still "scanning", so once the queue provider advances the phase to
-# "finding threads"/"drafting replies" it goes quiet and never fights that writer.
-( while true; do sleep 30; "$PY" "$REPO_DIR/scripts/saps_activity.py" heartbeat scanning "scanning X for threads" 2>/dev/null || true; done ) &
+SCAN_T0=$(date +%s)
+(
+  while true; do
+    sleep 20
+    _el=$(( $(date +%s) - SCAN_T0 ))
+    if [ "$_el" -lt 60 ]; then _dur="${_el}s"; else _dur="$(( _el / 60 ))m"; fi
+    _q=$(grep -c "kept=" "$OUT" 2>/dev/null || true); _q=${_q:-0}
+    _found=$(grep -oE "Batch has [0-9]+" "$OUT" 2>/dev/null | tail -1 | grep -oE "[0-9]+" | tail -1 || true)
+    if [ -n "$_found" ]; then
+      _lbl="scanning X for threads (${_dur} · ${_q} queries, ${_found} found)"
+    else
+      _lbl="scanning X for threads (${_dur} · ${_q} queries)"
+    fi
+    "$PY" "$REPO_DIR/scripts/saps_activity.py" heartbeat scanning "$_lbl" 2>/dev/null || true
+  done
+) &
 HB_PID=$!
 
 # Engagement mode (2026-06-26). The menu-bar toggle writes mode.json; this reads