social-autoposter 1.6.113 → 1.6.115

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.113",
-  "installedAt": "2026-06-25T19:38:00.335Z"
+  "version": "1.6.115",
+  "installedAt": "2026-06-26T20:55:06.436Z"
 }

package/mcp/manifest.json

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

@@ -168,6 +168,16 @@ class S4LMenuBar(rumps.App):
         self._posting_batch_done = 0
         self._spin_i = 0
         self._spinner = None  # fast rumps.Timer animating the title while busy
+        # Durable posting progress, derived from the review-queue PLAN rather than
+        # this process's in-memory burst queue. The in-memory counter dies on a
+        # menu bar restart and is blind to posts driven by the autopilot/agent, so
+        # the title used to fall back to plain "S4L" mid-drain. These track a drain
+        # by the plan's posted count climbing, with hysteresis across the multi-
+        # second gaps between individual posts so the indicator never blinks off.
+        self._posting_label = None
+        self._drain_baseline = None  # posted count just before this drain started
+        self._drain_last_posted = None
+        self._drain_last_change = 0.0
         # Reliable self-check of our own Accessibility (TCC) grant — this is the
         # faithful reading (our launchd process identity, not a parent's). Logged
         # so menubar.err.log records whether keystroke posting will work.
@@ -395,15 +405,70 @@ class S4LMenuBar(rumps.App):
     # animates the title with the label and stops itself when activity clears.
     # Both run on the main thread (rumps timers).
     def _poll_activity(self, _):
+        # Refresh the durable plan-based posting label (cheap: one small file read)
+        # so the title can show steady posting progress even when the server's
+        # per-post activity.json is momentarily empty between posts.
+        self._posting_label = self._compute_posting_label()
         act = st.read_activity()
-        if act and act.get("label") and self._spinner is None:
+        has_label = bool((act and act.get("label")) or self._posting_label)
+        if has_label and self._spinner is None:
             self._spin_i = 0
             self._spinner = rumps.Timer(self._spin, 0.12)
             self._spinner.start()
 
+    def _compute_posting_label(self):
+        """Posting progress from the durable review-queue plan, with hysteresis.
+
+        A drain is detected by the plan's posted count INCREASING (or the server's
+        activity.json reporting a post in flight) — never by the raw unposted
+        backlog, which sits non-zero for drafts merely awaiting review. The label
+        is held for a grace window after the last post so the indicator doesn't
+        blink back to "S4L" during the multi-second gaps between posts. Survives a
+        menu bar restart and reflects posts driven by the autopilot/agent, not just
+        this process's own approval queue."""
+        now = time.time()
+        try:
+            posted = st.review_queue_posted_count()
+        except Exception:
+            posted = None
+        act = st.read_activity()
+        act_posting = bool(act and "posting" in str(act.get("label") or ""))
+        if posted is None:
+            posted = self._drain_last_posted  # ride through a transient read miss
+        if posted is None:
+            return None
+        if self._drain_last_posted is None:
+            self._drain_last_posted = posted
+        advanced = posted > self._drain_last_posted
+        if advanced or act_posting:
+            if self._drain_baseline is None:
+                # New drain: baseline is the count just BEFORE its first post.
+                self._drain_baseline = self._drain_last_posted
+            self._drain_last_change = now
+        if advanced:
+            self._drain_last_posted = posted
+        if self._drain_baseline is None:
+            return None
+        # Drain is over once the server is idle AND no new post landed for a grace
+        # window (covers the long gaps between the last few slow posts).
+        if not act_posting and now - self._drain_last_change > 45.0:
+            self._drain_baseline = None
+            return None
+        sent = max(0, posted - self._drain_baseline)
+        return f"posting · {sent} sent"
+
     def _spin(self, _):
         act = st.read_activity()
         label = act.get("label") if act else None
+        act_state = act.get("state") if act else None
+        # For POSTING, prefer the menu bar's durable cumulative label over the
+        # server's per-call "1/1" so the count climbs smoothly and the indicator
+        # holds through the gaps between posts. Non-posting activity (scanning /
+        # drafting) keeps its own server label.
+        if self._posting_label and (
+            not label or act_state == "posting" or "posting" in str(label)
+        ):
+            label = self._posting_label
         if label:
             # The update arrow must stay visible even while a tool runs, so the
             # "update available" signal is never masked by activity. _tick skips the

package/mcp/menubar/s4l_state.py

@@ -349,6 +349,26 @@ def read_plan(plan_path):
         return None
 
 
+def review_queue_posted_count():
+    """Posts that have LANDED in the review-queue plan — the durable, cross-process
+    truth. Independent of the menu bar's in-memory burst queue (which dies on a
+    restart) and of WHICH process is posting (the menu bar worker, the autopilot,
+    or a host agent draining via post_drafts). Returns the posted count, or None
+    when the plan can't be read. Drives the menu-bar posting indicator so progress
+    stays visible regardless of how the drain is driven."""
+    plan_path = None
+    req = read_review_request()
+    if req:
+        plan_path = req.get("plan_path")
+    if not plan_path:
+        plan_path = "/tmp/twitter_cycle_plan_review-queue.json"
+    plan = read_plan(plan_path)
+    cands = (plan or {}).get("candidates")
+    if not cands:
+        return None
+    return sum(1 for c in cands if c.get("posted") is True)
+
+
 def review_drafts(plan):
     """Flatten a plan into the card model: only UNDECIDED candidates. A card that's
     posted, terminal (rejected/dead), or already approved is a settled decision and

package/mcp/package.json

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