@m13v/s4l 1.7.1 → 1.7.2-rc.10

package/mcp/dist/index.js

@@ -2244,7 +2244,17 @@ tool("post_drafts", {
             return;
         }
         c.terminal = true;
-        c.terminal_reason = "rejected";
+        // Preserve a more specific reason the menu bar already stamped locally
+        // (store_stamp_decision writes "human_rejected" for a card reject,
+        // discard_all_pending writes "human_discarded_all" for the bulk-discard
+        // button) BEFORE this loopback call ever fires, so by the time it lands
+        // here the local reason is already the more informative one. Only
+        // default to "rejected" when nothing more specific got there first
+        // (e.g. a reject driven straight from chat, with no menu-bar card
+        // involved at all).
+        if (!c.terminal_reason) {
+            c.terminal_reason = "rejected";
+        }
         c.approved = false;
         rejected.push(n);
     });
@@ -2837,6 +2847,16 @@ async function autopilotLoaded() {
 // Claude turn, writes the result back, and stops.
 // ===========================================================================
 const QUEUE_WORKER_PROMPT_VERSION = 8; // v8: worker polls internally (claude_job.py next --wait-seconds) instead of single-shot check-then-die. Empirically verified (2026-07-06) that a single long-running Bash call survives well past the host's ~90s between-tool-call inactivity kill — that timer only fires on MODEL silence, not on one in-flight tool call — so one Bash call can safely poll for QUEUE_WORKER_POLL_SECONDS before giving up. This cuts the every-minute spin-up-empty-then-die husk cycle down to roughly one session per poll window instead of one per cron tick. v7: universal type-blind worker. ONE task claims `--type any`; per-type execution notes (e.g. the v6 incremental-draft pacing for twitter-prep) moved into claude_job.py TYPE_TO_WORKER_NOTES and ride the prompt sidecar, so the worker prompt never mentions job types. Legacy per-type tasks get this same body on refresh and become interchangeable universal workers.
+// v9 (PLANNED, NOT IMPLEMENTED): delegate the actual drafting to a fresh
+// sub-agent per claimed job (claim -> delegate -> wait -> claim next, looped
+// within one continuous worker session) instead of drafting inline. Validated
+// via throwaway probe tasks 2026-07-07/08 (10 loop iterations, ~210s of real
+// delegated work, survives); the one hard constraint proven: the delegated
+// sub-agent must never fully idle-wait (e.g. background + wait on a Monitor
+// notification) or the host kills the whole parent+child chain in 1-3 min.
+// Never live-fire tested against a real production job. Full design, what's
+// validated vs not, and the implementation steps: docs/queue-worker-delegation-plan.md
+// Bump this constant to 9 only once that plan is actually implemented.
 const QUEUE_WORKER_PROMPT_MARKER = "s4l_queue_worker_prompt_version";
 // How long ONE `next --wait-seconds` call polls before giving up and exiting.
 // 240s (4 min): comfortably inside the 900s single-Bash-call survival verified

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.1",
-  "installedAt": "2026-07-09T00:28:03.233Z"
+  "version": "1.7.2-rc.10",
+  "installedAt": "2026-07-09T05:38:51.644Z"
 }

package/mcp/manifest.json

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

@@ -418,7 +418,21 @@ def _details_lines(d):
             lines.append(
                 f"Original thread ({lang.lower()}): {_truncate(d.get('thread_text'), 280)}"
             )
-        if (d.get("reply_text_en") or "").strip():
+        # Two-draft cards: reply_text_en only ever mirrors Draft A (the
+        # canonical single-draft field), so Draft B's translation would be
+        # silently dropped from the popover unless we read each slot's own
+        # text_en directly off the drafts array.
+        dual_drafts = d.get("drafts")
+        if isinstance(dual_drafts, list) and len(dual_drafts) == 2:
+            slot_labels = {"a": "Draft A", "b": "Draft B"}
+            for draft in dual_drafts:
+                text_en = (draft.get("text_en") or "").strip()
+                if text_en:
+                    label = slot_labels.get(
+                        (draft.get("variant") or "").strip().lower(), "Draft"
+                    )
+                    lines.append(f"{label} in English: {_truncate(text_en, 280)}")
+        elif (d.get("reply_text_en") or "").strip():
             lines.append(
                 f"Draft in English: {_truncate(d.get('reply_text_en'), 280)}"
             )
@@ -1586,6 +1600,37 @@ class _ReviewController(NSObject):
         self._log_surface(f"extended +{len(added)}")
         return len(added)
 
+    @objc.python_method
+    def prune_drafts(self, ns):
+        """Drop not-yet-reached drafts (plan index `n` in `ns`) from the stack,
+        e.g. a card the backend already retired (expired freshness gate, etc.)
+        while it was still waiting to be shown. Only ever removes entries AFTER
+        the current index, so the card on screen right now and everything
+        already decided are untouched -- nothing visible disappears out from
+        under the user. Refreshes the title-bar counter live. Returns the
+        count actually removed."""
+        if self._panel is None or not ns:
+            return 0
+        ns = set(ns)
+        kept = []
+        removed = 0
+        for i, d in enumerate(self._drafts):
+            if i > self._idx and d.get("n") in ns:
+                removed += 1
+                continue
+            kept.append(d)
+        if not removed:
+            return 0
+        self._drafts = kept
+        try:
+            self._panel.setTitle_(
+                f"s4l · Review draft {self._idx + 1} of {len(self._drafts)}"
+            )
+        except Exception:
+            pass
+        self._log_surface(f"pruned {removed} expired")
+        return removed
+
     @objc.python_method
     def _fire_decision(self):
         # Fire the per-card callback the instant a decision is made, so an
@@ -1818,6 +1863,22 @@ def extend_active(drafts):
         return 0
 
 
+def prune_active(ns):
+    """Remove not-yet-reached drafts (by plan index `n`) from the open review
+    card, if one is up -- e.g. a card that expired on the backend mid-review
+    (see merge_review_queue.py's backend sync). Never touches the card
+    currently on screen or any already-decided one, so nothing visible is
+    yanked out from under the user. Returns the count actually removed (0 if
+    no card is open or none of `ns` are still ahead in the stack). Main thread
+    only (called from the menu bar's rumps timer)."""
+    if _active is None or not ns:
+        return 0
+    try:
+        return _active.prune_drafts(ns)
+    except Exception:
+        return 0
+
+
 def active_status():
     """Live review-surface snapshot for the menu bar's unattended-review
     watchdog, or None when no card is open. Main thread only."""
@@ -1830,6 +1891,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

@@ -775,6 +775,67 @@ class S4LMenuBar(rumps.App):
             "that schedules the draft tasks for this account",
         )
 
+    def _finish_schedule_setup(self, _=None):
+        """One-click fix for schedule_state == 'missing' when
+        scheduled_task_selfheal.can_create_for_active_account() confirms a
+        session directory already exists for the active account (2026-07-08):
+        quit Claude, create the registration via a direct file write (the
+        same heal() the update flow uses — see its module docstring for why
+        this is equivalent to what create_scheduled_task would produce), then
+        relaunch. Primary action for this case now instead of re-arm: no
+        clipboard paste, no chat turn required. Re-arm remains the fallback
+        for the rarer case where no session directory exists yet for the
+        active account (see _build_menu) — fix 5 never fabricates one.
+
+        No confirm dialog: the restart is already disclosed in the menu item
+        label itself ("...(restarts Claude)", _build_menu) — a modal repeating
+        that would just be a second click for information the user already
+        has (2026-07-09). The notify toast below still tells them it started."""
+        _capture_msg(
+            "S4L finish-schedule-setup clicked",
+            phase="draft_schedule",
+            reason="missing",
+            _extra={"scheduled_tasks": _registry_summary_for_capture()},
+        )
+        self._notify("S4L", "Restarting Claude Desktop… setting up your draft schedule.")
+        threading.Thread(target=self._finish_schedule_setup_work, daemon=True).start()
+
+    def _finish_schedule_setup_work(self):
+        try:
+            user_data_dirs = self._claude_user_data_dirs()
+            self._quit_claude_and_wait()
+            # Claude is down: the same safe window _rewrite_scheduled_task_cwd
+            # always required. In-process is fine here (unlike the update
+            # flow's _fresh variant) — no new bundle was just downloaded, so
+            # the currently-running code IS the current code; nothing to go
+            # stale against.
+            self._rewrite_scheduled_task_cwd()
+            self._relaunch_claude(user_data_dirs)
+            self._sig = None
+            # Verify rather than claim success unconditionally — the earlier,
+            # now-deleted silent restart-fix drew a direct complaint for
+            # giving zero feedback either way (2026-07-08). CREATED_GRACE in
+            # schedule_state.py means a freshly-created, never-yet-fired task
+            # already reads "ok", so this doesn't need to wait for an actual
+            # first fire — just for Claude to be back up and the file to have
+            # landed.
+            time.sleep(12)
+            state = self._schedule_state()
+            if state == "ok":
+                self._notify(
+                    "S4L drafts set up",
+                    "Your draft schedule is registered — drafting starts within a few minutes.",
+                )
+            else:
+                self._notify(
+                    "S4L couldn't finish setup",
+                    "Restarting didn't register the schedule. Open the S4L menu → "
+                    "“Set up draft schedule” to finish it manually.",
+                )
+        except Exception as e:
+            self._notify("S4L setup restart failed", str(e)[:140])
+            _capture(e, phase="finish_schedule_setup")
+
     # ---- schedule-state detection ----------------------------------------
     def _schedule_state(self):
         """Is the draft schedule registered AND running for the live account?
@@ -1079,7 +1140,7 @@ class S4LMenuBar(rumps.App):
                 "Uninstall: keep your X login + browser layer (quick uninstall).\n"
                 "Deep wipe: also remove the shared browser profiles + toolchain."
             ),
-            ok="Uninstall & Restart Claude", cancel="Cancel", other="Deep wipe",
+            ok="Uninstall & Restart Claude", cancel="Cancel", other="Deep wipe & Restart Claude",
         )
         if choice == 0:  # cancel
             return
@@ -2400,11 +2461,24 @@ class S4LMenuBar(rumps.App):
                     "schedule” to re-register it.",
                 )
             else:
-                self._notify(
-                    "S4L draft autopilot not scheduled",
-                    "No draft tasks are running on this Claude account (switching "
-                    "accounts clears them). Open the S4L menu → “Set up draft schedule”.",
-                )
+                can_selfheal = False
+                try:
+                    import scheduled_task_selfheal
+                    can_selfheal = scheduled_task_selfheal.can_create_for_active_account()
+                except Exception:
+                    pass
+                if can_selfheal:
+                    self._notify(
+                        "S4L draft autopilot not scheduled",
+                        "No draft tasks are running on this Claude account (switching "
+                        "accounts clears them). Open the S4L menu → “Finish setting up drafts”.",
+                    )
+                else:
+                    self._notify(
+                        "S4L draft autopilot not scheduled",
+                        "No draft tasks are running on this Claude account (switching "
+                        "accounts clears them). Open the S4L menu → “Set up draft schedule”.",
+                    )
             self._stall_notified = True
         elif not attention and self._stall_notified:
             if self._attention_clear_since is None:
@@ -2428,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 = (
@@ -2449,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).
@@ -2504,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:
@@ -2534,6 +2632,13 @@ class S4LMenuBar(rumps.App):
         #    live. This is the fix for the "card froze at 1 of 4 while 137 piled
         #    up" bug — drafts that arrived after the card opened used to be
         #    stranded because this method returned early on _review_active.
+        #    Also prune the other direction: any `n` this same stack used to
+        #    carry but that dropped out of the fresh `drafts` list (merge_review_
+        #    queue.py's backend sync just marked it terminal, most commonly the
+        #    freshness gate expiring it) is removed from the not-yet-reached part
+        #    of the stack, so an old card can't sit there waiting to be approved
+        #    into a silent no-op (see the 2026-07-09 "approved 3, nothing
+        #    posted" investigation).
         #  - Posting is DRAINING with no panel up (_review_active but not
         #    _panel_open): leave the signature untouched so the full pending set
         #    is presented fresh once the drain completes (don't pop a card mid-post).
@@ -2542,6 +2647,11 @@ class S4LMenuBar(rumps.App):
                 try:
                     import s4l_card
 
+                    prev_ns = {n for n, _ in (self._last_review_sig or ())}
+                    cur_ns = {d.get("n") for d in drafts}
+                    vanished = prev_ns - cur_ns
+                    if vanished:
+                        s4l_card.prune_active(vanished)
                     s4l_card.extend_active(drafts)
                 except Exception as e:
                     sys.stderr.write(f"[s4l-menubar] extend cards failed: {e}\n")
@@ -2800,6 +2910,66 @@ 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]
+        cids = [d.get("candidate_id") for d in drafts if d.get("candidate_id") is not None]
+
+        def _persist_discard():
+            try:
+                st.post_drafts(batch, reject=ns, timeout=60)
+            except Exception:
+                pass
+            try:
+                st.flip_discarded_candidates_skipped(cids)
+            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.
@@ -2905,7 +3075,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 = []
 
@@ -2927,7 +3097,6 @@ class S4LMenuBar(rumps.App):
             items.append(rumps.MenuItem("Resume S4L", callback=self._pause_toggle))
         else:
             items.append(rumps.MenuItem("Pause S4L", callback=self._pause_toggle))
-            items.append(self._label("   stop drafting/posting, keep Claude + tray running"))
         items.append(rumps.separator)
 
         # Attention = the draft schedule isn't running for THIS account (missing or
@@ -2988,7 +3157,32 @@ class S4LMenuBar(rumps.App):
                 items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
             else:
                 items.append(self._label("⚠ Draft tasks aren’t scheduled on this account"))
-                items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
+                # Prefer the automatic fix (2026-07-08): if the active account
+                # already has a session directory, _finish_schedule_setup can
+                # create the registration directly (heal() fix 5) with no
+                # clipboard paste needed. Fall back to re-arm only when fix 5
+                # has nowhere to write (no session dir yet for this account —
+                # it never fabricates one), since that's the one case where
+                # only the live create_scheduled_task host tool can help.
+                can_selfheal = False
+                try:
+                    import scheduled_task_selfheal
+                    can_selfheal = scheduled_task_selfheal.can_create_for_active_account()
+                except Exception:
+                    pass
+                if can_selfheal:
+                    # Say "restarts Claude" in the label itself, not just the
+                    # confirm modal — a menu item should be honest about a
+                    # disruptive action (closing/reopening the whole app)
+                    # before the user has committed to clicking it, matching
+                    # what the old "Restart Claude Desktop to fix" button made
+                    # obvious upfront (2026-07-08).
+                    items.append(rumps.MenuItem(
+                        "Finish setting up drafts (restarts Claude)",
+                        callback=self._finish_schedule_setup,
+                    ))
+                else:
+                    items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
             items.append(rumps.separator)
 
         if not runtime_ready:
@@ -2996,7 +3190,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
@@ -3006,19 +3200,15 @@ class S4LMenuBar(rumps.App):
         personal_on = bool(flags.get("personal_brand"))
         promo_on = bool(flags.get("promotion"))
         items.append(rumps.separator)
-        items.append(self._label("Engagement lanes"))
         pb_item = rumps.MenuItem("Personal brand", callback=self._toggle_personal)
         pb_item.state = 1 if personal_on else 0
         items.append(pb_item)
-        items.append(self._label("   organic, link-free engagement"))
         pr_item = rumps.MenuItem("Product promotion", callback=self._toggle_promotion)
         pr_item.state = 1 if promo_on else 0
         items.append(pr_item)
-        items.append(self._label("   promoting your products (link replies)"))
         if personal_on and promo_on:
             # Both lanes on: the split becomes meaningful, so offer the presets.
             share = st.read_split()
-            items.append(self._label(f"   both on · cycles split {self._split_pct(share)}"))
             split_menu = rumps.MenuItem(f"Lane split: {self._split_pct(share)}")
             for preset in self.SPLIT_PRESETS:
                 it = rumps.MenuItem(
@@ -3035,7 +3225,6 @@ class S4LMenuBar(rumps.App):
         # carries a Feedback button); named for what it does to the pipeline,
         # not the mechanism.
         items.append(rumps.MenuItem("Give overall feedback to AI…", callback=self._menu_feedback))
-        items.append(self._label("   overall guidance, steers future drafts"))
         # While the update-verify marker is pending, the pipeline copy still
         # resolves the OLD version (it only advances once the restarted server
         # re-provisions repo/package, ~2 min), so the snapshot honestly reports
@@ -3062,8 +3251,10 @@ class S4LMenuBar(rumps.App):
             items.append(rumps.separator)
             items.append(rumps.MenuItem("Tidy autopilot history…", callback=self._prompt_relocate_tasks))
         items.append(rumps.separator)
-        items.append(rumps.MenuItem("Uninstall S4L…", callback=self._reset_machine))
-        items.append(rumps.MenuItem("Quit", callback=self._quit_app))
+        quit_menu = rumps.MenuItem("Quit or Uninstall")
+        quit_menu.add(rumps.MenuItem("Uninstall S4L…", callback=self._reset_machine))
+        quit_menu.add(rumps.MenuItem("Quit", callback=self._quit_app))
+        items.append(quit_menu)
 
         # Collapse consecutive/edge separators so an empty section (e.g. State C
         # now renders no status labels) can't leave a doubled or dangling divider.
@@ -3147,8 +3338,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,78 @@ 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 flip_discarded_candidates_skipped(candidate_ids):
+    """Flip each bulk-discarded candidate's twitter_candidates row to
+    status='skipped', skip_reason='human_discarded_all' — the same DB effect a
+    normal reject gets for free as a side effect of its review-events insert
+    (see review-events/route.ts). The bulk-discard path deliberately never
+    ships a review event (that's the whole point — it must not reach the
+    feedback digest), so without this direct call the row would stay
+    'pending' until the independent age-based freshness gate happens to expire
+    it, wide open to re-discovery/re-drafting of the exact draft a human just
+    discarded. One PATCH per candidate via the SAME direct-HTTP path
+    flush_review_events already uses (http_api), so this never touches
+    review_events. Best-effort: a candidate that already expired/posted by the
+    time this runs (404, no longer 'pending') is a no-op, not a failure."""
+    if not candidate_ids:
+        return
+    try:
+        from http_api import api_patch
+    except Exception as err:
+        sys.stderr.write(
+            f"[s4l-state] flip_discarded_candidates_skipped: http_api unavailable "
+            f"({type(err).__name__}: {err}); {len(candidate_ids)} candidate(s) left 'pending'\n"
+        )
+        sys.stderr.flush()
+        return
+    for cid in candidate_ids:
+        try:
+            api_patch(
+                "/api/v1/twitter-candidates/by-id",
+                {"id": cid, "action": "mark_skipped", "reason": "human_discarded_all"},
+                ok_on_404=True,
+            )
+        except Exception as err:
+            sys.stderr.write(
+                f"[s4l-state] flip_discarded_candidates_skipped: PATCH failed for "
+                f"candidate_id={cid} ({type(err).__name__}: {err})\n"
+            )
+            sys.stderr.flush()
+
+
 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.1",
+  "version": "1.7.2-rc.10",
   "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.1",
+  "version": "1.7.2-rc.10",
   "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",