social-autoposter 1.6.136 → 1.6.138

package/mcp/dist/index.js

@@ -2039,8 +2039,14 @@ async function autopilotLoaded() {
 // fires every minute, claims ONE job, runs the pipeline's own prompt as its
 // Claude turn, writes the result back, and stops.
 // ===========================================================================
-const QUEUE_WORKER_PROMPT_VERSION = 2;
+const QUEUE_WORKER_PROMPT_VERSION = 4; // v4: tighten per-run draft cap to 2 (v3's 3 still overran the ~100-134s kill window on heavy cycles, ~20% timeouts)
 const QUEUE_WORKER_PROMPT_MARKER = "saps_queue_worker_prompt_version";
+// Max replies the Phase-2b draft worker may draft in ONE scheduled run. The host
+// SIGTERMs scheduled sessions after ~90-110s; drafting more than a handful never
+// submits in time. Start conservative so a run always finishes inside the window;
+// undrafted candidates stay "pending" and return next cycle (lossless). Can be
+// raised once drains are confirmed reliably under the kill budget.
+const DRAFT_BUDGET_CANDIDATES = 2;
 // One spec per worker task. queueType MUST match scripts/claude_job.py TAG_TO_TYPE.
 const QUEUE_WORKERS = [
     { taskId: PHASE1_TASK_ID, queueType: "twitter-query", human: "Phase 1 X search-query drafting" },
@@ -2142,6 +2148,17 @@ function queueWorkerBody(spec) {
     const job = path.join(repoDir(), "scripts", "claude_job.py");
     const sd = sapsStateDir();
     const outDir = queueDir();
+    // The Phase-2b "twitter-prep" worker drafts replies inside the scheduled
+    // session, which the host hard-kills (SIGTERM) after ~90-110s of wall time.
+    // Drafting all of one cycle's candidates blows past that every time, so the
+    // job is never submitted and times out (see provider.log drain timeouts).
+    // Cap how many it drafts per run so it always finishes and submits in time;
+    // the inner prompt already treats undrafted candidates as "pending" timing
+    // deferrals, so they come back next cycle (lossless, self-healing).
+    const isDraft = spec.queueType === "twitter-prep";
+    const draftBudgetNote = isDraft
+        ? ` Per the TIME BUDGET above, draft AT MOST the first ${DRAFT_BUDGET_CANDIDATES} candidates and OMIT the rest; do not attempt them all.`
+        : "";
     return [
         `You are the S4L "${spec.human}" queue worker. Run ONE iteration, then STOP.`,
         ``,
@@ -2151,6 +2168,26 @@ function queueWorkerBody(spec) {
             `You do this with Bash and Write, and NOTHING else. This run is unattended — ` +
             `reaching for any other tool, or trying to "investigate", STALLS it forever.`,
         ``,
+        ...(isDraft
+            ? [
+                `TIME BUDGET (read before step 2; this OVERRIDES anything the inner prompt ` +
+                    `says about "no cap" or drafting "every" candidate): this unattended ` +
+                    `session is HARD-KILLED after about 90 seconds. You physically cannot ` +
+                    `draft more than a few replies before that kill, and if you are killed ` +
+                    `mid-draft the pipeline receives NOTHING and the whole cycle is wasted. ` +
+                    `So work to this rule: draft replies for AT MOST the first ` +
+                    `${DRAFT_BUDGET_CANDIDATES} candidates in the prompt (they are pre-sorted ` +
+                    `strongest-first), then IMMEDIATELY do step 3 (write your result and ` +
+                    `submit). Every candidate you do not draft is a TIMING DEFERRAL, NOT a ` +
+                    `rejection: OMIT it from BOTH the "candidates" and "rejected" arrays. The ` +
+                    `inner prompt explicitly allows this (omitted candidates stay "pending" ` +
+                    `and a later run re-judges them, so nothing is lost). A valid result with ` +
+                    `${DRAFT_BUDGET_CANDIDATES} or FEWER solid drafts that you submit IN TIME ` +
+                    `is a SUCCESS; being killed with nothing submitted is the only failure. ` +
+                    `When unsure, draft fewer and submit sooner.`,
+                ``,
+            ]
+            : []),
         `Steps:`,
         `1. Claim the next job. Run this EXACT Bash command:`,
         `     ${py} ${job} next --type ${spec.queueType} --prompt-file --state-dir ${sd}`,
@@ -2162,7 +2199,7 @@ function queueWorkerBody(spec) {
             `or truncated, keep reading the same file with offsets until EOF. If schema_file ` +
             `is not null, read it too. Follow the prompt EXACTLY and produce the SINGLE JSON ` +
             `object it asks for. If a schema is present, your JSON MUST satisfy it. Output ` +
-            `ONLY that JSON object — no prose, no markdown, no code fences.`,
+            `ONLY that JSON object — no prose, no markdown, no code fences.${draftBudgetNote}`,
         `3. Submit it. Write your JSON object to ${outDir}/out-<job_id>.json using the ` +
             `Write tool (substitute the real job_id), then run this EXACT Bash command:`,
         `     ${py} ${job} result --job <job_id> --result-file ${outDir}/out-<job_id>.json --state-dir ${sd}`,

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.136",
-  "installedAt": "2026-06-29T04:09:39.530Z"
+  "version": "1.6.138",
+  "installedAt": "2026-06-29T18:00:31.054Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.136",
+  "version": "1.6.138",
   "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_menubar.py

@@ -133,6 +133,12 @@ REARM_PROMPT = (
 # scheduler's per-minute cadence + a slow claim.
 AUTOPILOT_STALL_SECONDS = 180
 
+# A job CLAIMED but never finished (sits in running/ this long) means a worker
+# picked it up and then wedged mid-run (the claude -p drafting child died / never
+# spawned). Generous enough that the longest real drafting turn never trips it.
+# Keep in sync with RUNNING_STALL_SECONDS (scripts/autopilot_stall_watch.py).
+AUTOPILOT_RUNNING_STALL_SECONDS = 900
+
 # A worker task whose lastRunAt is within this many seconds is "firing" — the host
 # scheduler runs them every minute, so a fresh stamp means the live account's
 # schedule is active. 7 min tolerates host throttling + a restart gap without
@@ -452,6 +458,18 @@ class S4LMenuBar(rumps.App):
           (2) FAST: a draft job has sat unclaimed in pending/ past
               AUTOPILOT_STALL_SECONDS -> catches a fresh stall ~3 min in, before
               the first full producer timeout has even latched (1).
+          (3) IN-FLIGHT: a draft job was claimed (moved to running/) but never
+              finished within AUTOPILOT_RUNNING_STALL_SECONDS -> the worker picked
+              it up and then wedged mid-run. Self-clearing (the file is removed on
+              result or swept next cycle), so unlike the abandoned drain latch it
+              does NOT stay stale after recovery.
+
+        NOTE: kept in sync with scripts/autopilot_stall_watch.py (the fleet Sentry
+        backstop). The menu-bar ⚠ itself is driven by _schedule_state, NOT this
+        method — the attention/⚠ path keys off schedule_state so a firing-but-
+        momentarily-empty queue stays green (an earlier drain-latch ⚠ stayed stale
+        after recovery and was deliberately removed). This method exists for the
+        watcher-parity contract and _stall_reason.
         """
         qroot = os.path.join(st.state_dir(), "claude-queue")
         # (1) latched producer drain-status
@@ -478,6 +496,22 @@ class S4LMenuBar(rumps.App):
                 return True
         except Exception:
             pass
+        # (3) in-flight running-age (claimed then wedged). running/ is flat.
+        try:
+            oldest = None
+            for jf in glob.glob(os.path.join(qroot, "running", "*.json")):
+                if jf.endswith(".tmp"):
+                    continue
+                try:
+                    m = os.path.getmtime(jf)
+                except OSError:
+                    continue
+                if oldest is None or m < oldest:
+                    oldest = m
+            if oldest is not None and (time.time() - oldest) > AUTOPILOT_RUNNING_STALL_SECONDS:
+                return True
+        except Exception:
+            pass
         return False
 
     def _recent_worker_outcome(self, window=600):

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "1.6.136",
+  "version": "1.6.138",
   "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.136",
+  "version": "1.6.138",
   "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/_check_block.py

@@ -0,0 +1,37 @@
+import asyncio, sys
+from playwright.async_api import async_playwright
+
+PROFILE = "https://x.com/Web3Mohsin"
+STATUS  = "https://x.com/Web3Mohsin/status/2071449607092183151"
+
+async def grab(page, url, shot):
+    await page.goto(url, wait_until="domcontentloaded")
+    await page.wait_for_timeout(6000)
+    try:
+        txt = await page.inner_text("body")
+    except Exception as e:
+        txt = f"<no body text: {e}>"
+    await page.screenshot(path=shot, full_page=False)
+    return txt
+
+async def main():
+    async with async_playwright() as p:
+        b = await p.chromium.connect_over_cdp("http://127.0.0.1:9555")
+        ctx = b.contexts[0]
+        page = await ctx.new_page()
+        who = ""
+        try:
+            await page.goto("https://x.com/home", wait_until="domcontentloaded")
+            await page.wait_for_timeout(3000)
+        except Exception as e:
+            who = f"<home err {e}>"
+        prof = await grab(page, PROFILE, "/tmp/blk_profile.png")
+        stat = await grab(page, STATUS, "/tmp/blk_status.png")
+        print("==== PROFILE URL:", page.url)
+        print("==== PROFILE TEXT (first 1500) ====")
+        print(prof[:1500])
+        print("\n==== STATUS TEXT (first 1500) ====")
+        print(stat[:1500])
+        await page.close()
+
+asyncio.run(main())

package/scripts/autopilot_stall_watch.py

@@ -40,6 +40,12 @@ import time
 
 # Keep in sync with AUTOPILOT_STALL_SECONDS (menubar) / AUTOPILOT_STALL_MS (index.ts).
 STALL_SECONDS = 180
+# A job CLAIMED but never finished (sits in running/ this long) means a worker
+# picked it up and then died mid-run — the claude -p drafting child never came up
+# or crashed. Must be generous enough to clear the longest real drafting turn so a
+# healthy run never trips it. Keep in sync with AUTOPILOT_RUNNING_STALL_SECONDS
+# (menubar). See _oldest_running_age.
+RUNNING_STALL_SECONDS = 900
 # Require the stall to persist this many consecutive checks before paging, so a
 # transient slow claim (e.g. right after a Claude restart) doesn't false-alarm.
 # At StartInterval 120 that is ~6 min of continuous stall.
@@ -136,6 +142,30 @@ def _oldest_pending_age() -> float | None:
     return time.time() - oldest
 
 
+def _oldest_running_age() -> float | None:
+    """Seconds since the oldest CLAIMED-but-unfinished job was written, or None if
+    nothing is in flight. A worker claims by moving a job pending/ -> running/ and
+    only removes it on result, so a job lingering in running/ far past any real
+    drafting turn means the worker claimed it and then wedged mid-run (dead/never-
+    spawned claude -p child). This is the ONLY signal for that case: pending-age is
+    silent (the job left pending/) and the producer's drain latch hasn't fired yet
+    (it's still inside its own timeout). running/ is flat (see claude_job.py)."""
+    run_root = os.path.join(_queue_root(), "running")
+    oldest = None
+    for jf in glob.glob(os.path.join(run_root, "*.json")):
+        if jf.endswith(".tmp"):
+            continue
+        try:
+            m = os.path.getmtime(jf)
+        except OSError:
+            continue
+        if oldest is None or m < oldest:
+            oldest = m
+    if oldest is None:
+        return None
+    return time.time() - oldest
+
+
 def _read_state() -> dict:
     try:
         with open(_watch_state_path()) as f:
@@ -169,11 +199,16 @@ def _sentry():
 
 def main() -> int:
     age = _oldest_pending_age()
+    run_age = _oldest_running_age()
     timeouts = _consecutive_timeouts()
-    # Durable latch OR fast pending-age (see the two helpers). Either alone is a
-    # stall; both must be gated on the autopilot actually being configured here.
+    # Three complementary signals, OR'd; all gated on the autopilot actually being
+    # configured here. (1) durable producer drain latch, (2) fast pending-age (job
+    # never claimed), (3) running-age (job claimed then wedged mid-run). (3) is the
+    # only one that catches a worker dying after it picked up the job.
     stalled = _autopilot_configured() and (
-        timeouts >= 1 or (age is not None and age > STALL_SECONDS)
+        timeouts >= 1
+        or (age is not None and age > STALL_SECONDS)
+        or (run_age is not None and run_age > RUNNING_STALL_SECONDS)
     )
     # A rate-limit stall is expected and self-heals at the quota reset — never page
     # for it (and re-arm can't fix it). Treat it as "not an actionable stall" so the
@@ -193,21 +228,33 @@ def main() -> int:
 
     consecutive += 1
     age_str = f"{int(age)}s" if age is not None else "n/a (between cycles)"
+    run_age_str = f"{int(run_age)}s" if run_age is not None else "n/a (none in flight)"
+    # Distinguish the two shapes so the alert points at the right cause: a claimed-
+    # but-wedged job (running-age) is a mid-run worker death, not an orphaned routine.
+    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()
+            cause = (
+                "a worker claimed a draft job and then died mid-run (claude -p child "
+                "never came up / crashed)"
+                if wedged_inflight
+                else "scheduled-task routines likely orphaned — Claude Desktop account change?"
+            )
             sentry.capture_message(
                 "social-autoposter autopilot stalled: draft jobs are not being "
-                "drained (scheduled-task routines likely orphaned — Claude Desktop "
-                f"account change?). producer consecutive timeouts={timeouts}, "
-                f"oldest pending job age={age_str}, sustained {consecutive} checks.",
+                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="error",
                 tags={
                     "component": "autopilot",
                     "issue": "stall",
+                    "stall_shape": "inflight_wedged" if wedged_inflight else "not_draining",
                     "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 "",
                 },
             )
             sentry.flush()
@@ -215,7 +262,7 @@ def main() -> int:
             # No Sentry (helper/SDK missing) -> at least leave a local breadcrumb.
             sys.stderr.write(
                 f"[stall-watch] autopilot stalled (timeouts={timeouts}, "
-                f"age={age_str}) but Sentry report failed\n"
+                f"pending_age={age_str}, running_age={run_age_str}) but Sentry report failed\n"
             )
         alerted = True
 

package/scripts/claude_job.py

@@ -86,6 +86,43 @@ def _act_clear() -> None:
     except Exception:
         pass
 
+
+def _fmt_dur(secs: float) -> str:
+    """Compact human duration for the menu-bar label: '45s', '12m'."""
+    s = int(max(0, secs))
+    return f"{s}s" if s < 60 else f"{s // 60}m"
+
+
+def _act_write_progress(
+    qtype: str, created: float, claimed_at: float | None, now: float
+) -> None:
+    """Granular in-flight menu-bar label, so a wedged cycle reads as the TRUTH
+    instead of a static 'drafting replies' that lingers for the whole producer
+    timeout (the failure mode where the worker never claims the job, or claims it
+    and dies mid-run, looked identical to healthy drafting before this).
+
+      - job still in pending/ (no worker has claimed it) -> '<base> (queued <dur>)'
+        counting from enqueue. A growing 'queued 18m' is the unmistakable tell that
+        a scheduled-task worker is orphaned and nothing is draining.
+      - job claimed (pending file gone -> moved to running/) -> '<base> (<dur>)'
+        counting from the claim, i.e. real drafting elapsed.
+
+    Purely cosmetic and best-effort: a write failure must never affect the queue."""
+    if _activity is None:
+        return
+    sl = TYPE_TO_ACTIVITY.get(qtype)
+    if not sl:
+        return
+    state, base = sl
+    if claimed_at is None:
+        label = f"{base} (queued {_fmt_dur(now - created)})"
+    else:
+        label = f"{base} ({_fmt_dur(now - claimed_at)})"
+    try:
+        _activity.write(state, label)
+    except Exception:
+        pass
+
 # claude flags that consume the following argv token as their value, so the
 # value is never mistaken for the positional prompt.
 VALUE_FLAGS = {
@@ -499,17 +536,27 @@ def cmd_provider(ns) -> int:
     res_path = os.path.join(result_dir(), f"{job_id}.json")
     deadline = created + ns.timeout
     last_hb = created  # last menu-bar heartbeat (see below)
+    claimed_at = None  # set the moment a worker moves the job pending/ -> running/
     while time.time() < deadline:
+        now = time.time()
+        # A worker claims a job by atomically renaming pending/ -> running/, so the
+        # pending file vanishing is our signal that drafting actually STARTED (vs.
+        # the job still sitting unclaimed). Latch the claim time once so the label
+        # can distinguish "waiting for a worker" from "worker is drafting" and show
+        # the right elapsed for each.
+        if claimed_at is None and not os.path.exists(pending_path):
+            claimed_at = now
         # Heartbeat the menu-bar label so its `since` stays fresh for the whole
         # multi-minute block. The consumer (s4l_state.read_activity) ages a label
         # out after a TTL, so without this refresh a long drafting turn would look
         # stale and the spinner would wrongly blink to idle. Refreshing here means
         # the label is fresh EXACTLY while real work is happening, and stops the
         # instant we return or die — so the consumer's TTL can then expire it
-        # instead of it freezing forever. Throttled to ~10s; best-effort only.
-        now = time.time()
+        # instead of it freezing forever. Throttled to ~10s; best-effort only. The
+        # label now carries claim-state + elapsed so a stuck cycle reads honestly
+        # ("queued 18m") instead of a reassuring static "drafting replies".
         if now - last_hb >= 10:
-            _act_write(qtype)
+            _act_write_progress(qtype, created, claimed_at, now)
             last_hb = now
         if os.path.exists(res_path):
             try:

package/scripts/memory_snapshot.py

@@ -169,6 +169,7 @@ def parse_vm_stat() -> dict[str, Any]:
         "inactive_mb": pages_mb("pages_inactive"),
         "speculative_mb": pages_mb("pages_speculative"),
         "wired_mb": pages_mb("pages_wired_down"),
+        "purgeable_mb": pages_mb("pages_purgeable"),
         "compressed_mb": pages_mb("pages_occupied_by_compressor"),
         "swapins": pages.get("swapins"),
         "swapouts": pages.get("swapouts"),
@@ -176,6 +177,30 @@ def parse_vm_stat() -> dict[str, Any]:
     }
 
 
+def memory_pressure_pct_free() -> float | None:
+    """macOS-authoritative availability signal.
+
+    `memory_pressure` prints "System-wide memory free percentage: N%". THIS is the
+    number to trust for "is the box starved?" — NOT vm_stat "pages free", which sits
+    near-zero by design (macOS hoards RAM as cached/inactive/compressed pages, so a
+    tiny "free" is the normal healthy state, not starvation). Best-effort; returns
+    None if the tool is unavailable so the caller can fall back to a pages estimate.
+    """
+    out = run(["/usr/bin/memory_pressure"], timeout=6.0)
+    if not out:
+        return None
+    m = re.search(r"free percentage:\s*([\d.]+)", out)
+    return round(float(m.group(1)), 1) if m else None
+
+
+def swap_used_mb() -> float | None:
+    """Active swap in MB from vm.swapusage (a real-pressure corroborator)."""
+    sysctl_bin = "/usr/sbin/sysctl" if Path("/usr/sbin/sysctl").exists() else "sysctl"
+    out = run([sysctl_bin, "-n", "vm.swapusage"], timeout=2.0)
+    m = re.search(r"used\s*=\s*([\d.]+)M", out or "")
+    return round(float(m.group(1)), 1) if m else None
+
+
 def launchd_jobs(by_pid: dict[int, dict[str, Any]], children: dict[int, list[int]]) -> list[dict[str, Any]]:
     out = run(["launchctl", "list"], timeout=5.0)
     jobs: list[dict[str, Any]] = []
@@ -601,12 +626,42 @@ def build_summary() -> dict[str, Any]:
     rows, by_pid, children = parse_ps()
     mem = parse_vm_stat()
     total = mem.get("total_mb")
-    free = mem.get("free_mb")
+    # macOS memory accounting: "available" headroom is what can be handed to a
+    # process WITHOUT paging — free + inactive + speculative + purgeable, all of
+    # which the OS reclaims on demand. The real footprint is total - available.
+    # Do NOT use vm_stat "pages free" as the headline: it is near-zero by design
+    # (macOS keeps RAM full of reclaimable cache), so total-minus-free reads ~99%
+    # and falsely looks like starvation. That trap caused a wrong OOM call once.
+    avail_parts = [mem.get(k) for k in ("free_mb", "inactive_mb", "speculative_mb", "purgeable_mb")]
+    available = (
+        round(sum(p for p in avail_parts if isinstance(p, (int, float))), 1) if mem else None
+    )
     used = (
-        round(float(total) - float(free), 1)
-        if isinstance(total, (int, float)) and isinstance(free, (int, float))
+        round(float(total) - float(available), 1)
+        if isinstance(total, (int, float)) and isinstance(available, (int, float))
+        else None
+    )
+    # pct_free is kept CONSISTENT with the MB figures above (available / total) so a
+    # reader never sees two contradictory percentages. `pressure_pct` is the separate
+    # OS pressure gauge from `memory_pressure` (counts evictable file cache as free, so
+    # it reads higher) — it is the most robust starvation detector, so `health` is
+    # derived from it, falling back to pct_free only when the tool is unavailable.
+    pct_free = (
+        round(available / total * 100, 1)
+        if isinstance(total, (int, float)) and isinstance(available, (int, float)) and total
         else None
     )
+    pressure_pct = memory_pressure_pct_free()
+    basis = pressure_pct if pressure_pct is not None else pct_free
+    if basis is None:
+        health = "unknown"
+    elif basis < 10:
+        health = "critical"
+    elif basis < 20:
+        health = "warn"
+    else:
+        health = "ok"
+    swap_used = swap_used_mb()
     slim_groups = {
         name: {"count": g["count"], "rss_mb": g["rss_mb"]}
         for name, g in group_summaries(rows).items()
@@ -634,9 +689,13 @@ def build_summary() -> dict[str, Any]:
         "mem": {
             "total_mb": total,
             "used_mb": used,
-            "free_mb": free,
+            "available_mb": available,
+            "pct_free": pct_free,
+            "pressure_pct": pressure_pct,
+            "health": health,
             "wired_mb": mem.get("wired_mb"),
             "compressed_mb": mem.get("compressed_mb"),
+            "swap_used_mb": swap_used,
             "swapouts": mem.get("swapouts"),
         },
         "groups": slim_groups,