@m13v/s4l 1.7.2-rc.5 → 1.7.2-rc.7

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.2-rc.5",
-  "installedAt": "2026-07-09T01:43:14.354Z"
+  "version": "1.7.2-rc.7",
+  "installedAt": "2026-07-09T02:45:11.565Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.2-rc.5",
+  "version": "1.7.2-rc.7",
   "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

@@ -1844,6 +1844,36 @@ def active_status():
         return None
 
 
+def dismiss_active():
+    """Force-close the open review panel WITHOUT firing on_decision/on_complete,
+    for a bulk discard whose fate for every remaining card was already decided
+    elsewhere (the menu bar's store-level "Discard all pending drafts"). A
+    normal windowShouldClose_ close still fires on_complete (leftover cards are
+    just undecided); this path skips both callbacks entirely so the bulk
+    discard's own bookkeeping is the only thing that runs. Returns True if a
+    panel was actually open."""
+    global _active
+    c = _active
+    if c is None or c._panel is None:
+        return False
+    try:
+        c._close_stats_popover()
+    except Exception:
+        pass
+    try:
+        c._panel.setDelegate_(None)
+        c._panel.close()
+    except Exception:
+        pass
+    c._panel = None
+    c._on_complete = None
+    c._on_decision = None
+    _active = None
+    _log(f"closed: dismissed (bulk discard, {len(c._decisions)} decided of {len(c._drafts)})")
+    _write_review_state(last_event="dismissed")
+    return True
+
+
 def heal_active():
     """Self-heal an unattended card: move it to the top-right of the screen the
     pointer is on and raise it, WITHOUT stealing keyboard focus (the user is

package/mcp/menubar/s4l_menubar.py

@@ -2502,6 +2502,11 @@ class S4LMenuBar(rumps.App):
             if ob
             else 0
         )
+        # Pending draft-card count, for the bulk-discard menu item (visibility +
+        # label). Cheap local JSON reads, same source _maybe_start_review uses.
+        _, pending_drafts = self._pending_review()
+        pending_count = len(pending_drafts)
+
         # _update_available / _latest_version are in the signature so a freshly
         # detected update rebuilds the menu (adding "Update now & restart Claude Desktop") even mid-run.
         sig = (
@@ -2523,10 +2528,14 @@ class S4LMenuBar(rumps.App):
             schedule_state,
             self._stall_reason_info,
             os.path.exists(PAUSE_FLAG),
+            pending_count,
         )
         if sig != self._sig:
             self._sig = sig
-            self._build_menu(runtime_ready, setup_complete, ob, blocker, snap, attention, schedule_state)
+            self._build_menu(
+                runtime_ready, setup_complete, ob, blocker, snap, attention, schedule_state,
+                pending_count=pending_count,
+            )
 
         # Draft-review pop-ups: if a draft cycle left a review request, present the
         # cards. Don't start a review mid-run (the spinner means a tool is active).
@@ -2578,6 +2587,21 @@ class S4LMenuBar(rumps.App):
         self._posting_batch_total = 0
         self._posting_batch_done = 0
 
+    def _pending_review(self):
+        """(batch_id, undecided draft cards) from the durable review store —
+        the same source _maybe_start_review presents from. Cheap (small local
+        JSON reads); drives the menu's bulk-discard item, both its visibility
+        and what it acts on."""
+        try:
+            req = st.read_review_request()
+            batch = (req or {}).get("batch_id")
+            if not batch:
+                return None, []
+            plan = st.read_plan(req.get("plan_path") or "")
+            return batch, st.review_drafts(plan)
+        except Exception:
+            return None, []
+
     def _maybe_start_review(self):
         req = st.read_review_request()
         if not req:
@@ -2874,6 +2898,61 @@ class S4LMenuBar(rumps.App):
         if not any(d.get("approved") for d in decisions):
             self._notify("S4L", "No drafts approved — nothing posted.")
 
+    def _discard_all_pending(self, _=None):
+        """Bulk-discard every pending draft card: rejected with NO reason,
+        instantly, and — deliberately — without shipping a review event for any
+        of them. A normal per-card reject always ships one (feeding the
+        feedback-digest -> learned_preferences rail, see _ship_review_event);
+        this bulk "clear the backlog" action carries no per-card judgment
+        signal, so it must never reach that rail (user-specified 2026-07-08)."""
+        batch, drafts = self._pending_review()
+        if not batch or not drafts:
+            return
+        n = len(drafts)
+        choice = _show_alert(
+            title="Discard all pending drafts?",
+            message=(
+                f"Discards all {n} pending draft(s) right now, with no reason "
+                "given. None of them will post or be shown for review again. "
+                "This does not feed the AI feedback loop (learned_preferences) "
+                "the way an individual reject does."
+            ),
+            ok="Discard All", cancel="Cancel",
+        )
+        if choice != 1:
+            return
+        try:
+            st.discard_all_pending(drafts)
+        except Exception as e:
+            sys.stderr.write(f"[s4l-menubar] discard all pending failed: {e}\n")
+            sys.stderr.flush()
+            _capture(e, phase="discard_all_pending")
+            self._alert("Discard failed", str(e)[:200])
+            return
+        ns = [d.get("n") for d in drafts if d.get("n") is not None]
+
+        def _persist_discard():
+            try:
+                st.post_drafts(batch, reject=ns, timeout=60)
+            except Exception:
+                pass
+
+        threading.Thread(target=_persist_discard, daemon=True).start()
+        try:
+            import s4l_card
+
+            s4l_card.dismiss_active()
+        except Exception:
+            pass
+        with self._review_lock:
+            self._panel_open = False
+            if self._posts_outstanding <= 0:
+                self._review_active = False
+                self._reset_posting_progress_locked()
+        self._last_review_sig = None
+        st.clear_review_request()
+        self._notify("S4L", f"Discarded {n} pending draft(s).")
+
     def _ensure_post_worker(self):
         # One persistent daemon worker drains the approved-card queue. It never
         # exits (avoids an enqueue-vs-exit race) — an idle parked thread is cheap.
@@ -2979,7 +3058,7 @@ class S4LMenuBar(rumps.App):
             self.title = "S4L"
 
     # ---- menu construction ------------------------------------------------
-    def _build_menu(self, runtime_ready, setup_complete, ob, blocker, snap, attention=False, schedule_state="ok"):
+    def _build_menu(self, runtime_ready, setup_complete, ob, blocker, snap, attention=False, schedule_state="ok", pending_count=0):
         self.menu.clear()
         items = []
 
@@ -3094,7 +3173,7 @@ class S4LMenuBar(rumps.App):
         elif not setup_complete:
             items += self._state_b(ob, blocker)
         else:
-            items += self._state_c(snap)
+            items += self._state_c(snap, pending_count)
 
         # Engagement lanes — ALWAYS visible (every state), not just post-setup, so
         # the user can see + flip either lane any time. Two INDEPENDENT checkmarks
@@ -3242,8 +3321,15 @@ class S4LMenuBar(rumps.App):
     # The engagement-mode toggles live in _build_menu (shown in EVERY state), and
     # there is deliberately no "Run draft cycle" / "Post approved drafts" item
     # (the autopilot drafts on its own; approving a review card already posts it).
-    def _state_c(self, snap):
-        return []
+    def _state_c(self, snap, pending_count=0):
+        if pending_count <= 0:
+            return []
+        return [
+            rumps.MenuItem(
+                f"Discard {pending_count} pending draft{'s' if pending_count != 1 else ''}…",
+                callback=self._discard_all_pending,
+            )
+        ]
 
 
 if __name__ == "__main__":

package/mcp/menubar/s4l_state.py

@@ -770,6 +770,39 @@ def store_stamp_decision(batch, decision):
     return bool(_store_update(mutate))
 
 
+def discard_all_pending(drafts):
+    """Bulk-reject an entire pending set (the menu bar's "Discard all pending
+    drafts"), durably and atomically in ONE lock acquisition. Each candidate is
+    stamped terminal with NO reason (reject_category=None), same as a card's
+    "Reject, no reason" button. Deliberately distinct from store_stamp_decision:
+    this never ships a review event, by design, so a bulk "clear the backlog"
+    click never reaches the review-events/feedback-digest rail and can't
+    pollute learned_preferences with a non-judgment. Returns how many were
+    stamped."""
+
+    def mutate(data):
+        done = 0
+        for d in drafts:
+            c = _match_candidate(data, d.get("n"), d.get("candidate_id"))
+            if c is None or c.get("posted") is True or c.get("terminal") is True:
+                continue
+            c["terminal"] = True
+            c["terminal_reason"] = "human_discarded_all"
+            c["decision"] = {
+                "approved": False,
+                "text": c.get("reply_text") or "",
+                "edited": False,
+                "drop_link": False,
+                "loved": False,
+                "reject_category": None,
+                "decided_at": time_iso(),
+            }
+            done += 1
+        return done
+
+    return _store_update(mutate) or 0
+
+
 def store_mark_post_failed(batch, n, candidate_id=None, error=None):
     """A decided post that FAILED surfaces via notification/dashboard, not by
     re-presenting the card and not by endless resume retries."""

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.2-rc.5",
+  "version": "1.7.2-rc.7",
   "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.2-rc.5",
+  "version": "1.7.2-rc.7",
   "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/salvage_orphaned_prep_results.py

@@ -18,10 +18,14 @@ Safe by construction:
   - Best-effort: any single failure is logged and skipped; never raises.
 
 Degradation vs a normal cycle: salvaged candidates skip the cycle's post-provider
-top-N selection (so MORE cards, which is fine) and lack the tail-link / experiments
-arm stamp that run-twitter-cycle.sh's plan writer adds after the provider returns.
-The reply text itself is complete. A salvaged card is strictly better than a lost
-draft.
+top-N selection (so MORE cards, which is fine), lack the tail-link / experiments
+arm stamp that run-twitter-cycle.sh's plan writer adds after the provider returns,
+and (two-draft schema only) lack assigned_style/assigned_mode, which live in the
+cycle's shell variables, not the model output. The reply text itself IS complete
+end-to-end (_mirror_two_draft_fields backfills reply_text/drafts from
+draft_a_text/draft_b_text for the post-2026-07-07/08 two-draft schema, since the
+model output alone has no reply_text field to check for completeness). A salvaged
+card is strictly better than a lost draft.
 
 Usage:
     python3 scripts/salvage_orphaned_prep_results.py            # automated (safe age gate)
@@ -59,6 +63,52 @@ except Exception:  # standalone fallbacks
             pass
 
 
+def _mirror_two_draft_fields(candidates):
+    """Backfill reply_text/drafts for two-draft-schema candidates (2026-07-07/08
+    redesign) that reach salvage. The normal cycle path (run-twitter-cycle.sh)
+    mirrors draft_a_text onto reply_text/engagement_style/drafts right after the
+    model returns, but salvage bypasses that shell-side step entirely, so an
+    orphaned post-redesign result reached review cards with NEITHER field set.
+    The menubar card (s4l_card.py) reads d.get("drafts") first, then falls back
+    to d.get("reply_text") or "", so those cards rendered the thread with a
+    completely empty editable reply box despite draft_a_text/draft_b_text
+    holding real, already-drafted content (root-caused 2026-07-09 via
+    candidate 374925 and 4 siblings, all missing 'experiments' too, confirming
+    they came through this salvage path rather than a normal cycle write).
+
+    assigned_style/assigned_mode are deliberately left OUT (not set to None,
+    just absent): the picker's per-cycle style assignment lives only in
+    run-twitter-cycle.sh's shell variables, not in the model's JSON output, so
+    it can't be recovered here. twitter_post_plan.py already has a documented
+    fallback for that ("assigned_mode key absent" -> use the plan-level
+    assignment, itself None for a salvaged plan), so leaving the keys out is
+    the safe, already-supported degradation, same class as the existing
+    no-experiments-stamp degradation.
+    """
+    for c in candidates:
+        if not isinstance(c, dict) or "draft_a_text" not in c or "reply_text" in c:
+            continue
+        c["reply_text"] = c.get("draft_a_text") or ""
+        c["engagement_style"] = c.get("draft_a_style") or ""
+        c["new_style"] = c.get("draft_a_new_style")
+        if c.get("draft_a_text_en"):
+            c["reply_text_en"] = c["draft_a_text_en"]
+        draft_b_text = c.get("draft_b_text")
+        if not c.get("is_reused_draft") and draft_b_text:
+            c["drafts"] = [
+                {
+                    "variant": "a", "text": c.get("draft_a_text") or "",
+                    "style": c.get("draft_a_style") or "",
+                    "text_en": c.get("draft_a_text_en"),
+                },
+                {
+                    "variant": "b", "text": draft_b_text,
+                    "style": c.get("draft_b_style") or "",
+                    "text_en": c.get("draft_b_text_en"),
+                },
+            ]
+
+
 def _is_prep_result(obj):
     """True iff obj looks like a twitter-prep result (drafted candidates).
 
@@ -142,6 +192,7 @@ def main():
                     pass
             continue
 
+        _mirror_two_draft_fields(obj["candidates"])
         n = len(obj["candidates"])
         age_min = (now - st.st_mtime) / 60.0
         _plog(f"[salvage] ORPHAN prep result job {job_id}: producer never consumed it "