social-autoposter 1.6.129 → 1.6.131

package/mcp/dist/index.js

@@ -2045,7 +2045,11 @@ async function autopilotLoaded() {
     }
     let auto_update_on = false;
     try {
-        const res = await run("launchctl", ["list"], { timeoutMs: 10_000 });
+        // noTee: this status probe dumps the entire launchd job table (hundreds of
+        // lines) and fires on every dashboard/status poll — teeing it flooded Cloud
+        // Logging (~98% of an install's log volume). We only need the substring
+        // check, so keep the output in-memory and out of the relay. (2026-06-28)
+        const res = await run("launchctl", ["list"], { timeoutMs: 10_000, noTee: true });
         auto_update_on = res.stdout.split("\n").some((l) => l.includes(UPDATER_LABEL));
     }
     catch {

package/mcp/dist/repo.js

@@ -100,7 +100,7 @@ export function run(cmd, args, opts = {}) {
         let sinkOutBuf = "";
         let sinkErrBuf = "";
         const sinkPump = (chunk, which, buf) => {
-            const sink = lineSink;
+            const sink = opts.noTee ? null : lineSink;
             if (!sink)
                 return buf;
             buf += chunk;
@@ -155,7 +155,7 @@ export function run(cmd, args, opts = {}) {
                         /* ignore */
                     }
             }
-            const sink = lineSink;
+            const sink = opts.noTee ? null : lineSink;
             if (sink) {
                 if (sinkOutBuf)
                     try {

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.129",
-  "installedAt": "2026-06-28T04:38:52.828Z"
+  "version": "1.6.131",
+  "installedAt": "2026-06-28T23:09:36.990Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.129",
+  "version": "1.6.131",
   "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

@@ -112,21 +112,12 @@ SETUP_PROMPT = (
 )
 DRAFT_PROMPT = "Run a social-autoposter draft cycle and show me the drafts to review."
 UPDATE_PROMPT = "Update social-autoposter to the latest version."
-# Re-arm after the draft autopilot's scheduled-task routines got orphaned — most
-# often because the user logged Claude Desktop into a different account, which
-# leaves the routines registered only under the OLD account's session so nothing
-# drains the draft queue (the SKILL.md files persist globally, so the old presence
-# check stayed falsely "green"). The host's create_scheduled_task only exists
-# inside an interactive Desktop session, so recovery routes through the composer
-# like Setup/Draft do. Targeted: it does NOT redo X/login/project setup.
-REARM_PROMPT = (
-    "The social-autoposter draft autopilot stopped running (its scheduled-task "
-    "routines are missing under this Claude account). Re-arm it now: call "
-    "queue_setup, then for EACH returned task call the host tool "
-    "create_scheduled_task with its taskId, cronExpression, and prompt verbatim, "
-    "then call run_draft_cycle once to verify a draft card appears. Do not redo my "
-    "X connection or project setup."
-)
+# NOTE: re-arm does NOT drive the Claude UI. Pasting a prompt to make the agent
+# call create_scheduled_task proved unreliable (keystroke automation into Electron
+# races focus/timing even with Accessibility granted). Instead, re-arm writes the
+# two worker routines straight into the host's scheduled-tasks.json registry during
+# a Claude restart (the same down-window mechanism the cwd-rewrite already uses) —
+# deterministic, no Accessibility, works headless. See _rearm_work().
 
 # A pending draft job older than this (seconds) with nothing claiming it means no
 # routine is draining the queue — the worker would claim within a minute if it
@@ -255,6 +246,10 @@ class S4LMenuBar(rumps.App):
         # Cached stall flag (set each _tick) so the 1s activity poll can suppress a
         # stale "drafting" spinner that would otherwise mask the ⚠ in the title.
         self._stalled = False
+        # Cached (kind, detail) explaining a stall so the menu offers the right
+        # action: 'orphaned' -> Re-arm, 'rate_limited' -> wait/switch (no Re-arm),
+        # 'failing' -> generic. Recomputed each tick while stalled.
+        self._stall_reason_info = ("", "")
         self._reloc_timer = rumps.Timer(self._maybe_relocate_tasks, 90)
         self._reloc_timer.start()
         self._tick(None)
@@ -339,21 +334,161 @@ class S4LMenuBar(rumps.App):
         self._send_to_claude(DRAFT_PROMPT)
 
     def _rearm(self, _=None):
-        self._send_to_claude(REARM_PROMPT)
-
-    def _rearm_copy(self, _=None):
-        """Always-works fallback: copy the re-arm prompt to the clipboard and open
-        Claude, no Accessibility/automation needed. The user pastes it (⌘V) and
-        presses Enter. This is the escape hatch for when the keystroke-paste path
-        is blocked by a stale TCC grant."""
-        copied = self._copy_to_clipboard(REARM_PROMPT)
-        self._open_claude()
-        self._notify(
-            "S4L · re-arm prompt copied" if copied else "S4L",
-            "Paste it into Claude (⌘V) and press Enter to re-arm the autopilot."
-            if copied
-            else "Open Claude and ask it to re-arm the draft autopilot.",
+        """One-click recovery: re-create the draft autopilot's scheduled-task
+        routines under the CURRENT Claude account, deterministically — no GUI
+        keystrokes, no Accessibility. The host caches its registry in memory and
+        clobbers live edits, so we must edit while Claude is DOWN; this therefore
+        restarts Claude. Heavy work + the restart run off the main thread."""
+        self._notify("S4L", "Re-arming autopilot… Claude will restart briefly.")
+        threading.Thread(target=self._rearm_work, daemon=True).start()
+
+    def _rearm_work(self):
+        try:
+            # Bring Claude down so registry edits stick (it reloads the file fresh
+            # at launch; a live edit is clobbered on the next scheduler fire).
+            subprocess.run(["osascript", "-e", 'tell application "Claude" to quit'],
+                           capture_output=True, timeout=20)
+            time.sleep(4)
+            subprocess.run(["killall", "Claude"], capture_output=True)
+            time.sleep(2)
+            subprocess.run(["killall", "-9", "Claude"], capture_output=True)
+            time.sleep(1)
+            n = self._ensure_routines_registered()
+            # Keep cwd correct + drop the deprecated task while we're down.
+            self._rewrite_scheduled_task_cwd()
+            subprocess.run(["open", "-a", CLAUDE_APP], capture_output=True, timeout=20)
+            self._sig = None
+            if n:
+                self._notify(
+                    "S4L re-armed",
+                    "Draft autopilot routines restored. Drafts resume within a few minutes.",
+                )
+            else:
+                self._notify(
+                    "S4L",
+                    "Couldn't find where to register routines. Try again, or sign back "
+                    "into the original Claude account.",
+                )
+        except Exception as e:
+            self._notify("S4L re-arm failed", str(e)[:140])
+            _capture(e, phase="rearm")
+
+    # ---- re-arm: write routines straight into the host registry -----------
+    def _worker_record_templates(self):
+        """Clone existing host-authored worker records (so the shape is EXACTLY what
+        the scheduler accepts). Returns {taskId: record_dict}. Empty if none found
+        (e.g. a box that never had them)."""
+        out = {}
+        try:
+            for f in glob.glob(SCHED_REGISTRY_GLOB):
+                try:
+                    with open(f) as fh:
+                        d = json.load(fh)
+                except Exception:
+                    continue
+                for t in d.get("scheduledTasks", []) or []:
+                    tid = t.get("id")
+                    if tid in WORKER_TASK_IDS and tid not in out:
+                        out[tid] = dict(t)
+        except Exception:
+            pass
+        return out
+
+    def _make_worker_record(self, tid, template):
+        """Build a routine record. Prefer cloning a host-authored template (exact
+        accepted shape); override the fields that must be right for this account."""
+        rec = dict(template) if template else {}
+        rec["id"] = tid
+        rec["cronExpression"] = "* * * * *"
+        rec["enabled"] = True
+        rec["filePath"] = os.path.join(
+            os.path.expanduser("~"), ".claude", "scheduled-tasks", tid, "SKILL.md"
         )
+        rec["cwd"] = WORKER_CWD
+        rec.setdefault("createdAt", int(time.time() * 1000))
+        # Let the host recompute run-history for this account.
+        for k in ("lastRunAt", "lastScheduledFor", "fireAt"):
+            rec.pop(k, None)
+        return rec
+
+    def _session_registry_targets(self):
+        """Where to write routines: every existing scheduled-tasks.json (fix in
+        place) PLUS the most-recently-active session dir (the live account, which
+        may have no registry yet). Covers whichever account is logged in without
+        having to know which it is."""
+        targets = set(glob.glob(SCHED_REGISTRY_GLOB))
+        base = os.path.join(
+            os.path.expanduser("~"), "Library", "Application Support", "Claude",
+            "claude-code-sessions",
+        )
+        best, best_m = None, -1.0
+        try:
+            for ws in os.listdir(base):
+                wsp = os.path.join(base, ws)
+                if not os.path.isdir(wsp):
+                    continue
+                for inner in os.listdir(wsp):
+                    ip = os.path.join(wsp, inner)
+                    if not os.path.isdir(ip):
+                        continue
+                    try:
+                        m = os.path.getmtime(ip)
+                    except OSError:
+                        continue
+                    if m > best_m:
+                        best_m, best = m, ip
+        except Exception:
+            pass
+        if best:
+            targets.add(os.path.join(best, "scheduled-tasks.json"))
+        return sorted(targets)
+
+    def _ensure_routines_registered(self):
+        """Create the two queue-worker routines (cwd=~/.s4l-worker, enabled) in the
+        live account's registry — recovering an account-switch orphan WITHOUT the
+        Claude UI. Caller MUST run this while Claude is DOWN. Best-effort; never
+        raises. Returns the number of registry files written."""
+        templates = self._worker_record_templates()
+        try:
+            os.makedirs(WORKER_CWD, exist_ok=True)
+        except Exception:
+            pass
+        written = 0
+        for f in self._session_registry_targets():
+            try:
+                if os.path.exists(f):
+                    with open(f) as fh:
+                        d = json.load(fh)
+                else:
+                    d = {"scheduledTasks": [], "recordedSkips": {}}
+            except Exception:
+                d = {"scheduledTasks": [], "recordedSkips": {}}
+            tasks = d.get("scheduledTasks") or []
+            by_id = {t.get("id"): t for t in tasks}
+            dirty = False
+            for tid in WORKER_TASK_IDS:
+                if tid in by_id:
+                    t = by_id[tid]
+                    if not t.get("enabled") or t.get("cwd") != WORKER_CWD:
+                        t["enabled"] = True
+                        t["cwd"] = WORKER_CWD
+                        dirty = True
+                else:
+                    tasks.append(self._make_worker_record(tid, templates.get(tid)))
+                    dirty = True
+            if not dirty:
+                continue
+            d["scheduledTasks"] = tasks
+            try:
+                os.makedirs(os.path.dirname(f), exist_ok=True)
+                fd, tmp = tempfile.mkstemp(dir=os.path.dirname(f))
+                with os.fdopen(fd, "w") as fh:
+                    json.dump(d, fh, indent=2)
+                os.replace(tmp, f)
+                written += 1
+            except Exception:
+                pass
+        return written
 
     # ---- autopilot liveness (the false-green fix) -------------------------
     def _autopilot_stalled(self):
@@ -398,6 +533,57 @@ class S4LMenuBar(rumps.App):
             pass
         return False
 
+    def _recent_worker_outcome(self, window=600):
+        """Inspect worker transcripts written in the last `window` seconds (the
+        ~/.s4l-worker bucket). Returns (ran, rate_limit_msg):
+          ran           — a routine actually EXECUTED recently (a worker that runs
+                          leaves a transcript; an orphaned/not-firing account leaves
+                          none). This is what tells "routines fire but fail" apart
+                          from "routines gone".
+          rate_limit_msg— set when a recent run hit the Claude weekly/usage limit
+                          (re-arm cannot fix that); carries a short 'resets …' string.
+        Account-agnostic on purpose: it keys off actual execution, not a per-account
+        lastRunAt that freezes (and lies) after an account switch."""
+        ran = False
+        limit_msg = None
+        try:
+            now = time.time()
+            files = glob.glob(
+                os.path.expanduser("~/.claude/projects/*s4l-worker*/*.jsonl")
+            )
+            recent = [f for f in files if (now - os.path.getmtime(f)) <= window]
+            recent.sort(key=os.path.getmtime, reverse=True)
+            if recent:
+                ran = True
+            for f in recent[:5]:
+                try:
+                    txt = open(f).read()
+                except Exception:
+                    continue
+                low = txt.lower()
+                if "weekly limit" in low or "usage limit" in low or "hit your limit" in low:
+                    import re
+                    m = re.search(r"resets [^\"\\]{0,40}", txt)
+                    limit_msg = m.group(0).strip().rstrip(".") if m else "Claude usage limit reached"
+                    break
+        except Exception:
+            pass
+        return ran, limit_msg
+
+    def _stall_reason(self):
+        """Why drafts aren't draining, so the menu offers the RIGHT action:
+          ('orphaned', '')        routines aren't firing -> Re-arm fixes it.
+          ('rate_limited', msg)   routines fire but the account hit its Claude
+                                  limit -> Re-arm is useless; wait/switch account.
+          ('failing', '')         routines fire but drafts fail for another reason.
+        Only meaningful when _autopilot_stalled() is True."""
+        ran, limit_msg = self._recent_worker_outcome()
+        if limit_msg:
+            return ("rate_limited", limit_msg)
+        if not ran:
+            return ("orphaned", "")
+        return ("failing", "")
+
     def _toggle_mode(self, _=None):
         """Flip personal-brand <-> promotion. Pure local state write (no model,
         no network): the cycle reads mode.json on its next run. Rebuild the menu
@@ -887,6 +1073,11 @@ class S4LMenuBar(rumps.App):
         # which would otherwise own the title and hide the ⚠. _poll_activity reads
         # this to drop that stale spinner.
         self._stalled = stalled
+        # When stalled, work out WHY so the menu (and this notification) offer the
+        # right action — re-arm only helps when routines aren't firing, not when
+        # they fire but hit the Claude usage limit. Only computed while stalled
+        # (it reads worker transcripts), and cached for _build_menu.
+        self._stall_reason_info = self._stall_reason() if stalled else ("", "")
 
         # Spinner owns the title while busy; _spin already keeps the ⬆ visible there.
         if not busy:
@@ -899,14 +1090,27 @@ class S4LMenuBar(rumps.App):
                 blocker.get("message", "Setup is blocked"),
             )
         self._last_blocker_code = blocker_code
-        # Notify once on the transition into a stall, with the one action that fixes
-        # it. Re-arms are user-driven (composer), so we don't spam every tick.
+        # Notify once on the transition into a stall, with the cause-specific action.
         if stalled and not self._stall_notified:
-            self._notify(
-                "S4L autopilot not running",
-                "No drafts are being generated (routines missing — did Claude's "
-                "account change?). Open the S4L menu and click “Re-arm autopilot”.",
-            )
+            kind, detail = self._stall_reason_info
+            if kind == "rate_limited":
+                self._notify(
+                    "S4L autopilot paused",
+                    "Claude usage limit reached" + (f" ({detail})" if detail else "")
+                    + ". Drafting resumes when the limit resets, or sign into a "
+                    "Claude account with quota.",
+                )
+            elif kind == "orphaned":
+                self._notify(
+                    "S4L autopilot not running",
+                    "The draft routines aren't running (did Claude's account "
+                    "change?). Open the S4L menu and click “Re-arm autopilot”.",
+                )
+            else:
+                self._notify(
+                    "S4L autopilot stalled",
+                    "Drafts aren't being produced. Open the S4L menu for options.",
+                )
             self._stall_notified = True
         elif not stalled:
             self._stall_notified = False
@@ -935,6 +1139,7 @@ class S4LMenuBar(rumps.App):
             snap.get("projects_total"),
             st.read_mode(),
             stalled,
+            self._stall_reason_info,
         )
         if sig != self._sig:
             self._sig = sig
@@ -1194,13 +1399,21 @@ class S4LMenuBar(rumps.App):
         # account switch): surface the one-click recovery FIRST, above the normal
         # state items, so it's the obvious next action.
         if stalled:
-            items.append(self._label("⚠ Autopilot not running — no drafts"))
-            items.append(rumps.MenuItem("Re-arm autopilot", callback=self._rearm))
-            # Always-works fallback when the keystroke-paste path is blocked by a
-            # stale Accessibility grant: copy the prompt so the user can paste it.
-            items.append(
-                rumps.MenuItem("Re-arm: copy prompt (paste in Claude)", callback=self._rearm_copy)
-            )
+            kind, detail = self._stall_reason_info
+            if kind == "rate_limited":
+                # Routines ARE firing; the account hit its Claude limit. Re-arm
+                # cannot fix that, so DON'T offer it — show the cause instead.
+                items.append(self._label("⚠ Autopilot paused — Claude usage limit"))
+                if detail:
+                    items.append(self._label(f"   {detail}"))
+                items.append(self._label("   Resumes at reset, or switch Claude account"))
+            elif kind == "orphaned":
+                # Routines aren't firing -> re-arm re-creates them.
+                items.append(self._label("⚠ Autopilot not running — no drafts"))
+                items.append(rumps.MenuItem("Re-arm autopilot", callback=self._rearm))
+            else:  # 'failing' — routines fire but drafts fail for another reason
+                items.append(self._label("⚠ Autopilot stalled — drafts failing"))
+                items.append(rumps.MenuItem("Re-arm autopilot", callback=self._rearm))
             items.append(rumps.separator)
 
         if not runtime_ready:

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "1.6.129",
+  "version": "1.6.131",
   "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.129",
+  "version": "1.6.131",
   "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

@@ -89,6 +89,32 @@ def _consecutive_timeouts() -> int:
         return 0
 
 
+def _recent_rate_limit(window: int = 1200) -> bool:
+    """True if a worker run in the last `window` seconds hit the Claude weekly/usage
+    limit. That stall is EXPECTED and auto-resets, so it must NOT page Sentry —
+    paging would be pure noise. Reads the ~/.s4l-worker transcript bucket."""
+    try:
+        now = time.time()
+        files = glob.glob(
+            os.path.expanduser("~/.claude/projects/*s4l-worker*/*.jsonl")
+        )
+        recent = sorted(
+            (f for f in files if (now - os.path.getmtime(f)) <= window),
+            key=os.path.getmtime,
+            reverse=True,
+        )[:5]
+        for f in recent:
+            try:
+                low = open(f).read().lower()
+            except Exception:
+                continue
+            if "weekly limit" in low or "usage limit" in low or "hit your limit" in low:
+                return True
+    except Exception:
+        pass
+    return False
+
+
 def _oldest_pending_age() -> float | None:
     """Seconds since the oldest unclaimed pending draft job was written, or None
     if nothing is pending (idle queue). The FAST signal: catches a fresh stall
@@ -149,6 +175,11 @@ def main() -> int:
     stalled = _autopilot_configured() and (
         timeouts >= 1 or (age is not None and age > 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
+    # episode resets and a LATER real stall (orphaned routines) still alerts.
+    if stalled and _recent_rate_limit():
+        stalled = False
 
     st = _read_state()
     consecutive = int(st.get("consecutive", 0))

package/scripts/memory_snapshot.py

@@ -424,6 +424,21 @@ def claude_queue_summary() -> dict[str, Any]:
             }
         except OSError:
             pass
+    # The producer's drain latch: consecutive_timeouts>=1 means the scheduled-task
+    # worker stopped draining (the definitive phase2b-stall signal). Surfacing it
+    # here lets the heartbeat carry it server-side, so a stall is visible centrally
+    # without SSHing the box. See claude_job.py _bump_drain_timeout / _clear_drain.
+    drain_path = root / "drain-status.json"
+    if drain_path.exists():
+        try:
+            ds = json.loads(drain_path.read_text())
+            summary["drain_status"] = {
+                "consecutive_timeouts": int(ds.get("consecutive_timeouts", 0) or 0),
+                "last_success_at": ds.get("last_success_at"),
+                "last_timeout_at": ds.get("last_timeout_at"),
+            }
+        except (OSError, ValueError, TypeError):
+            pass
     return summary
 
 
@@ -603,6 +618,14 @@ def build_summary() -> dict[str, Any]:
         else None
     )
     cq = claude_queue_summary()
+    ds = cq.get("drain_status") or {}
+    oldest = cq.get("oldest_age_sec")
+    consec = int(ds.get("consecutive_timeouts", 0) or 0)
+    # Mirror the MCP's autopilotStalled(): a latched producer timeout, OR a draft
+    # job that has sat unclaimed past 180s, means no scheduled-task worker is
+    # draining the queue. Carrying this on the heartbeat makes a phase2b stall
+    # visible in installation_resource_samples without SSHing the box.
+    stalled = bool(consec >= 1 or (isinstance(oldest, (int, float)) and oldest > 180))
     return {
         "ts": dt.datetime.now(dt.timezone.utc).astimezone().isoformat(timespec="seconds"),
         "hostname": socket.gethostname(),
@@ -621,6 +644,10 @@ def build_summary() -> dict[str, Any]:
         "claude_queue": {
             "pending": cq.get("pending_total", 0),
             "running": cq.get("running_total", 0),
+            "oldest_age_sec": oldest,
+            "stalled": stalled,
+            "consecutive_timeouts": consec,
+            "last_success_at": ds.get("last_success_at"),
         },
     }