@m13v/s4l 1.7.11 → 1.7.12-rc.2

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.11",
-  "installedAt": "2026-08-14T18:28:05.705Z"
+  "version": "1.7.12-rc.2",
+  "installedAt": "2026-08-20T01:59:29.922Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.11",
+  "version": "1.7.12-rc.2",
   "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/menubar/s4l_card.py

@@ -714,6 +714,34 @@ def _age_expiry_display(iso, platform):
     return text, urgent
 
 
+# Local hard-expire at the countdown site (2026-08-17): when a card's clock
+# crosses zero it is RETIRED locally (terminal, reason local_clock_expired)
+# instead of just relabeling itself "expired" while staying approvable. The
+# real freshness gate is cycle-driven (backend Phase 0 flip + merge-time
+# prune), so any stretch where cycles don't run — machine asleep on a dead
+# battery, producer down, hidden window absorbing drafts overnight — used to
+# leave long-expired cards presentable; approving one is a silent no-op
+# server-side (2026-07-09, and again on the 2026-08-17 hibernate wake, 14
+# cards approved 6-19h stale). Corner-card mode only: canvas tiles keep the
+# label-only behavior (the canvas is always an explicit user-opened surface
+# with its own replace flow). The on-screen card additionally requires
+# AUTO_EXPIRE_IDLE_SECONDS without interaction and an unedited draft before
+# it self-retires, so it is never yanked out from under someone actively
+# working the moment the clock crosses zero.
+AUTO_EXPIRE_IDLE_SECONDS = 60
+
+
+def _draft_expired(d):
+    """True when this draft's Phase 0 hard-expire deadline has passed — the
+    same clock the header countdown renders (_expiry_secs_left). False when
+    the countdown doesn't apply (reddit cards, missing timestamp)."""
+    d = d or {}
+    secs = _expiry_secs_left(
+        (d.get("stats") or {}).get("tweet_posted_at"), d.get("platform")
+    )
+    return secs is not None and secs <= 0
+
+
 # Hover popover on the header's age/expiry label (2026-07-15 per user): the
 # reviewer sees the countdown but not necessarily WHY it exists, so the
 # popover pairs the live seconds-granular clock with the reasoning behind the
@@ -1154,6 +1182,12 @@ class _ReviewController(NSObject):
         self._add_snooze_accessory(panel)
         self._panel = panel
         self._render()
+        if self._panel is None:
+            # The hard-expire sweep retired the ENTIRE stack inside that
+            # first _render (every draft past deadline, e.g. a wake after
+            # hibernate) and _finish already closed the panel. Don't order
+            # the dead panel back onto the screen.
+            return
         panel.orderFrontRegardless()
         self._log_surface("presented")
         if self._focus:
@@ -1371,7 +1405,41 @@ class _ReviewController(NSObject):
         return eye
 
     @objc.python_method
+    @objc.python_method
+    def _retire_expired_current(self):
+        """Stamp the CURRENT draft terminal as local_clock_expired and fire its
+        decision, without advancing (callers own what happens next). The swept
+        card was never reviewed, so per-card telemetry is cleared first: stale
+        interactions/dwell from the previously shown card must not ride along
+        on a machine decision."""
+        d = self._drafts[self._idx]
+        self._interactions = []
+        self._card_shown_at = None
+        self._selected_draft = None
+        _log(
+            f"auto-expired n={d.get('n')} cid={d.get('candidate_id')} "
+            f"(card {self._idx + 1} of {len(self._drafts)})"
+        )
+        self._record(False, auto_expired=True)
+        self._fire_decision()
+
     def _render(self):
+        # Hard-expire sweep (2026-08-17, corner-card mode only — see the
+        # AUTO_EXPIRE_IDLE_SECONDS block): retire every already-expired draft
+        # at the front of the stack BEFORE building UI for it, so a stack
+        # that sat through a sleep/hibernate never presents dead cards. No
+        # idle guard here — nothing on screen is being yanked; this card was
+        # about to be shown for the first time (or re-shown after a decision
+        # on its predecessor).
+        if self._host_view is None:
+            while self._idx < len(self._drafts) and _draft_expired(
+                self._drafts[self._idx]
+            ):
+                self._retire_expired_current()
+                self._idx += 1
+            if self._idx >= len(self._drafts):
+                self._finish()
+                return
         d = self._drafts[self._idx]
         # Fresh card (not a card <-> reason-picker swap): reset telemetry.
         if self._rendered_idx != self._idx:
@@ -1974,6 +2042,25 @@ class _ReviewController(NSObject):
             return
         try:
             d = self._drafts[self._idx]
+            # The on-screen card crossed its hard-expire deadline: retire it
+            # (terminal, local_clock_expired) instead of letting it sit
+            # approvable under an "expired" label — approving it is a silent
+            # server-side no-op. Guarded so it never yanks a card someone is
+            # actively working: requires AUTO_EXPIRE_IDLE_SECONDS with no
+            # interaction AND an unedited draft body. While either guard
+            # holds, the label keeps showing "expired"; the tick re-checks
+            # every second and retires once the user goes idle. Corner-card
+            # mode only (canvas tiles keep label-only behavior).
+            if self._host_view is None and _draft_expired(d):
+                idle_ok = (
+                    self._last_interaction_at is None
+                    or time.time() - self._last_interaction_at
+                    >= AUTO_EXPIRE_IDLE_SECONDS
+                )
+                if idle_ok and not self._draft_hand_edited(d):
+                    self._retire_expired_current()
+                    self._advance()
+                    return
             stats = d.get("stats") or {}
             text, urgent = _age_expiry_display(
                 stats.get("tweet_posted_at"), d.get("platform")
@@ -2236,7 +2323,25 @@ class _ReviewController(NSObject):
             return d.get("reply_text") or ""
 
     @objc.python_method
-    def _record(self, approved, reject_category=None, reject_note=None, loved=False):
+    def _draft_hand_edited(self, d):
+        """True when the on-screen text no longer matches ANY of this draft's
+        original bodies (reply_text plus each two-draft variant) — i.e. the
+        reviewer has invested a hand edit. Used only as an auto-expire guard,
+        so unknowable defaults to True (never yank what we can't verify)."""
+        try:
+            originals = {(d.get("reply_text") or "").strip()}
+            for dd in d.get("drafts") or []:
+                if isinstance(dd, dict):
+                    originals.add((dd.get("text") or "").strip())
+            return (self._current_text() or "").strip() not in originals
+        except Exception:
+            return True
+
+    @objc.python_method
+    def _record(
+        self, approved, reject_category=None, reject_note=None, loved=False,
+        auto_expired=False,
+    ):
         d = self._drafts[self._idx]
         # Two-draft cards: `orig` (what counts as "unedited") is whichever
         # draft is CURRENTLY SELECTED, not always the plan's default
@@ -2311,6 +2416,13 @@ class _ReviewController(NSObject):
                 "drop_link": bool(approved and drop_link),
                 "reject_category": reject_category,
                 "reject_note": (reject_note or "").strip() or None,
+                # Machine retirement, not a human judgment: the countdown
+                # crossed zero (see the local hard-expire block above). The
+                # store stamps terminal_reason=local_clock_expired and the
+                # menu bar ships NO review event for it (an expiry says
+                # nothing about draft quality; it must not reach the
+                # feedback-digest -> learned_preferences rail).
+                "auto_expired": bool(auto_expired),
                 "interactions": list(self._interactions),
                 "dwell_ms": self._dwell_ms(),
                 # Ride-along candidate context (from review_drafts) so the
@@ -2678,6 +2790,12 @@ def present_review(drafts, on_decision=None, on_complete=None, focus=False):
     _active = _ReviewController.alloc().initWithDrafts_onDecision_onComplete_focus_(
         drafts, on_decision, on_complete, focus
     )
+    if _active is not None and _active._panel is None:
+        # The hard-expire sweep finished the whole stack during the initial
+        # render (_finish set the module global to None, but this assignment
+        # just overwrote it with the dead controller). Clear it so
+        # extend/heal/status never operate on a closed surface.
+        _active = None
 
 
 def extend_active(drafts):

package/mcp/menubar/s4l_menubar.py

@@ -3568,7 +3568,12 @@ class S4LMenuBar(rumps.App):
         # built to avoid (2026-07-16 user report). Every other consequence of
         # a decision (review event, posting-queue enqueue) still happens
         # here, per draft, same as the normal single-card path.
-        self._ship_review_event(batch, decision)
+        # Auto-expiries (card countdown crossed the hard-expire deadline, see
+        # s4l_card's local hard-expire block) are machine retirements, not
+        # judgments: like Discard All, they must never reach the review-events
+        # -> feedback-digest -> learned_preferences rail.
+        if not decision.get("auto_expired"):
+            self._ship_review_event(batch, decision)
         if not decision.get("approved"):
             n = decision.get("n")
             # Durable local record FIRST, mirroring the approve branch below.
@@ -3585,6 +3590,15 @@ class S4LMenuBar(rumps.App):
             except Exception as e:
                 _capture(e, phase="reject_stamp_decision")
 
+            # Auto-expiries stop at the durable store stamp: no loopback call.
+            # The backend row's own Phase 0 freshness gate flips it
+            # status='expired' on the next cycle (same 6h/48h clock the card
+            # counted down), and the loopback needs Claude Desktop up — which
+            # is exactly what's NOT guaranteed in the sleep/wake and
+            # dead-producer scenarios this path exists for.
+            if decision.get("auto_expired"):
+                return
+
             def _persist_reject():
                 try:
                     st.approve_drafts(batch, reject=[n], timeout=30)
@@ -3679,7 +3693,19 @@ class S4LMenuBar(rumps.App):
                 "Review sooner from the S4L menu.",
             )
         elif not any(d.get("approved") for d in decisions):
-            self._notify("S4L", "No drafts approved — nothing posted.")
+            n_exp = sum(1 for d in decisions if d.get("auto_expired"))
+            if n_exp and n_exp == len(decisions):
+                # The whole stack self-retired (typically a wake after
+                # sleep/hibernate): say what happened instead of the generic
+                # line, or the vanished cards look like a bug.
+                plural = "s" if n_exp != 1 else ""
+                self._notify(
+                    "S4L",
+                    f"Discarded {n_exp} stale draft{plural} — past the "
+                    "freshness window, too old to post.",
+                )
+            else:
+                self._notify("S4L", "No drafts approved — nothing posted.")
 
     def _discard_all_pending(self, _=None):
         """Bulk-discard every pending draft card: rejected with NO reason,

package/mcp/menubar/s4l_state.py

@@ -895,6 +895,11 @@ def store_stamp_decision(batch, decision):
             # None on single-draft cards. Durable locally so the choice
             # survives even if the review-events flush never lands.
             "draft_choice": decision.get("draft_choice"),
+            # Machine retirement (card countdown crossed the Phase 0 hard-
+            # expire deadline with no cycle around to prune it — sleep/wake,
+            # dead producer). Distinct from a human reject in terminal_reason
+            # below so dashboards/audits never count it as a judgment.
+            "auto_expired": bool(decision.get("auto_expired")),
             "decided_at": time_iso(),
         }
         if decision.get("approved"):
@@ -903,7 +908,11 @@ def store_stamp_decision(batch, decision):
             c.pop("post_error", None)
         else:
             c["terminal"] = True
-            c["terminal_reason"] = "human_rejected"
+            c["terminal_reason"] = (
+                "local_clock_expired"
+                if decision.get("auto_expired")
+                else "human_rejected"
+            )
         c["decision"] = payload
         return True
 

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.11",
+  "version": "1.7.12-rc.2",
   "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.11",
+  "version": "1.7.12-rc.2",
   "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

@@ -840,8 +840,19 @@ def main() -> int:
 
     targets_by_pid: dict[int, dict] = {}  # dedup across the two rules below
     for uuid, members in groups.items():
-        if len(members) <= 1:
-            continue  # a healthy / interactive session — never touch.
+        if len(members) <= 1 and inflight is None:
+            # Queue unreadable: cannot tell a husk from a worker about to claim, so
+            # the conservative fallback never touches a lone session. When the queue
+            # IS readable, singleton groups get the same type-driven sweep as larger
+            # ones. The 2026-08-16 wedge: one warm session never exited, Desktop's
+            # per_task_limit therefore never spawned a sibling, and the old
+            # unconditional `len(members) <= 1: continue` guard meant the reaper and
+            # the scheduler starved each other for ~55 minutes (reapable=1, killed=0
+            # every cycle). Everything in `members` is already a metadata- or
+            # cwd-confirmed S4L worker (interactive sessions are spared upstream in
+            # snapshot()), so rule (1)'s invariant applies to a group of one exactly
+            # as it does to a group of ten: claimless past claim_grace = proven husk.
+            continue
         members.sort(key=lambda p: p["age"])  # ascending: newest first
 
         if inflight is not None: