@m13v/s4l 1.7.2-rc.10 → 1.7.2-rc.2

package/mcp/dist/index.js

@@ -2244,17 +2244,7 @@ tool("post_drafts", {
             return;
         }
         c.terminal = true;
-        // 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.terminal_reason = "rejected";
         c.approved = false;
         rejected.push(n);
     });

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.2-rc.10",
-  "installedAt": "2026-07-09T05:38:51.644Z"
+  "version": "1.7.2-rc.2",
+  "installedAt": "2026-07-09T01:12:07.771Z"
 }

package/mcp/manifest.json

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

@@ -1600,37 +1600,6 @@ 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
@@ -1863,22 +1832,6 @@ 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."""
@@ -1891,36 +1844,6 @@ 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

@@ -785,12 +785,19 @@ class S4LMenuBar(rumps.App):
         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."""
+        active account (see _build_menu) — fix 5 never fabricates one."""
+        _activate_front()
+        choice = _show_alert(
+            title="Finish setting up drafts?",
+            message=(
+                "Claude needs to restart once to finish registering your draft "
+                "schedule for this account. Its window will close and reopen "
+                "in a moment — drafting starts within a few minutes after."
+            ),
+            ok="Restart & Finish Setup", cancel="Cancel",
+        )
+        if choice != 1:
+            return
         _capture_msg(
             "S4L finish-schedule-setup clicked",
             phase="draft_schedule",
@@ -1140,7 +1147,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 & Restart Claude",
+            ok="Uninstall & Restart Claude", cancel="Cancel", other="Deep wipe",
         )
         if choice == 0:  # cancel
             return
@@ -2502,11 +2509,6 @@ 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 = (
@@ -2528,14 +2530,10 @@ 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,
-                pending_count=pending_count,
-            )
+            self._build_menu(runtime_ready, setup_complete, ob, blocker, snap, attention, schedule_state)
 
         # 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).
@@ -2587,21 +2585,6 @@ 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:
@@ -2632,13 +2615,6 @@ 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).
@@ -2647,11 +2623,6 @@ 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")
@@ -2910,66 +2881,6 @@ 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.
@@ -3075,7 +2986,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", pending_count=0):
+    def _build_menu(self, runtime_ready, setup_complete, ob, blocker, snap, attention=False, schedule_state="ok"):
         self.menu.clear()
         items = []
 
@@ -3097,6 +3008,7 @@ 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
@@ -3190,7 +3102,7 @@ class S4LMenuBar(rumps.App):
         elif not setup_complete:
             items += self._state_b(ob, blocker)
         else:
-            items += self._state_c(snap, pending_count)
+            items += self._state_c(snap)
 
         # Engagement lanes — ALWAYS visible (every state), not just post-setup, so
         # the user can see + flip either lane any time. Two INDEPENDENT checkmarks
@@ -3200,15 +3112,19 @@ 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(
@@ -3225,6 +3141,7 @@ 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
@@ -3251,10 +3168,8 @@ class S4LMenuBar(rumps.App):
             items.append(rumps.separator)
             items.append(rumps.MenuItem("Tidy autopilot history…", callback=self._prompt_relocate_tasks))
         items.append(rumps.separator)
-        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)
+        items.append(rumps.MenuItem("Uninstall S4L…", callback=self._reset_machine))
+        items.append(rumps.MenuItem("Quit", callback=self._quit_app))
 
         # 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.
@@ -3338,15 +3253,8 @@ 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, 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,
-            )
-        ]
+    def _state_c(self, snap):
+        return []
 
 
 if __name__ == "__main__":

package/mcp/menubar/s4l_state.py

@@ -770,78 +770,6 @@ 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.2-rc.10",
+  "version": "1.7.2-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.2-rc.10",
+  "version": "1.7.2-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/claude_job.py

@@ -60,6 +60,7 @@ except Exception:  # pragma: no cover - cosmetic only
 
 # script_tag -> queue type. ONLY pure text->JSON claude calls belong here.
 TAG_TO_TYPE = {
+    "run-twitter-cycle-queries": "twitter-query",
     "run-twitter-cycle-prep": "twitter-prep",
     "feedback-digest": "feedback-digest",
     # Topic-invention lane (queue-native since 2026-07-06; invent_topics.py
@@ -74,10 +75,11 @@ TAG_TO_TYPE = {
 }
 
 # queue type -> (activity state, label) the menu bar shows while the job is in
-# flight. Phase-2b prep is the reply drafting. Both the launchd provider (which
-# blocks for minutes) and the scheduled-task worker (which does the LLM turn)
-# narrate from this one map.
+# flight. Phase-1 queries drive the X search ("finding threads"); Phase-2b prep is
+# the reply drafting. Both the launchd provider (which blocks for minutes) and the
+# scheduled-task worker (which does the LLM turn) narrate from this one map.
 TYPE_TO_ACTIVITY = {
+    "twitter-query": ("scanning", "search"),
     "twitter-prep": ("drafting", "draft"),
     "feedback-digest": ("learning", "feedback"),
     "invent-topic": ("learning", "new topic"),

package/scripts/merge_review_queue.py

@@ -129,31 +129,16 @@ STATS_KEYS = (
 )
 
 
-def _sync_with_backend(cands: list) -> tuple[int, int]:
-    """One bulk /api/v1/twitter-candidates lookup for every still-open candidate
-    (not posted, not terminal), used for two things:
-
-      - stamp the discovery-time `stats` sidecar the card renders (candidates
-        that already have one are left alone), same as the old
-        _enrich_with_stats this replaces.
-      - notice when the backend has ALREADY retired a candidate this plan
-        still thinks is 'pending' (most commonly the Phase 0 freshness gate
-        flipping status='expired' after FRESHNESS_HOURS — see
-        skill/run-twitter-cycle.sh) and mark it terminal here too, same as a
-        human "discard all pending" would. Without this, a card can sit in
-        the review queue as an approvable draft long after the backend has
-        moved on; approving it later silently no-ops (post_drafts returns
-        posted:0, no browser ever launches, no post-*.log — see the
-        2026-07-09 "approved 3 cards, nothing posted" investigation).
-
-    Runs on EVERY merge (every cycle), not just once per candidate, so status
-    drift after the initial stamp is still caught while a card is still
-    pending. Best-effort: any API failure leaves every candidate untouched
-    (fail open, same as before). Returns (stamped_count, pruned_count)."""
-    pending = [c for c in cands if not c.get("posted") and not c.get("terminal") and _thread_url(c)]
-    if not pending:
-        return 0, 0
-    urls = sorted({_thread_url(c) for c in pending})[:500]
+def _enrich_with_stats(cands: list) -> int:
+    """Stamp a `stats` sidecar onto plan candidates that lack one, from the
+    twitter_candidates rows the discovery pipeline already wrote. ONE listing
+    call (/api/v1/twitter-candidates?tweet_urls=...) covers the whole queue.
+    Best-effort: any failure (offline box, missing identity, API error) leaves
+    candidates unstamped and NEVER blocks card delivery. Returns count stamped."""
+    want = [c for c in cands if not c.get("stats") and not c.get("posted") and _thread_url(c)]
+    if not want:
+        return 0
+    urls = sorted({_thread_url(c) for c in want})[:500]
     try:
         sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
         from http_api import api_get
@@ -164,24 +149,17 @@ def _sync_with_backend(cands: list) -> tuple[int, int]:
         )
         rows = (resp.get("data") or {}).get("candidates") or []
     except BaseException as e:  # http_api raises SystemExit on terminal failure
-        print(f"[merge_review_queue] backend sync skipped: {e}", file=sys.stderr)
-        return 0, 0
+        print(f"[merge_review_queue] stats enrichment skipped: {e}", file=sys.stderr)
+        return 0
     by_url = {str(r.get("tweet_url")): r for r in rows if r.get("tweet_url")}
     stamped = 0
-    pruned = 0
-    for c in pending:
+    for c in want:
         row = by_url.get(_thread_url(c))
         if not row:
             continue
-        if not c.get("stats"):
-            c["stats"] = {k: row.get(k) for k in STATS_KEYS}
-            stamped += 1
-        status = row.get("status")
-        if status and status != "pending":
-            c["terminal"] = True
-            c["discard_reason"] = f"backend_status_{status}"
-            pruned += 1
-    return stamped, pruned
+        c["stats"] = {k: row.get(k) for k in STATS_KEYS}
+        stamped += 1
+    return stamped
 
 
 def main() -> int:
@@ -277,15 +255,9 @@ def main() -> int:
         merged.append(c)
         added += 1
 
-    stamped, pruned = _sync_with_backend(merged)
+    stamped = _enrich_with_stats(merged)
     if stamped:
         print(f"[merge_review_queue] stamped stats on {stamped} candidate(s)", file=sys.stderr)
-    if pruned:
-        print(
-            f"[merge_review_queue] pruned {pruned} candidate(s) already retired by the "
-            "backend (expired/etc.) before they were reviewed",
-            file=sys.stderr,
-        )
 
     plan_obj = {"candidates": merged}
     if plan_created_at:
@@ -302,17 +274,15 @@ def main() -> int:
         _atomic_write(dst, plan_obj)
         ensure_store_symlink()
 
-        # Refresh the review-request marker the menu bar polls (count = pending,
-        # not posted, not terminal -- a just-pruned expired card must not still
-        # inflate the badge).
-        pending_count = len([c for c in merged if not c.get("posted") and not c.get("terminal")])
+        # Refresh the review-request marker the menu bar polls (count = pending, not posted).
+        pending = len([c for c in merged if not c.get("posted")])
         project = ns.project or batch.get("project") or (new_cands[0].get("matched_project") if new_cands else None)
         _atomic_write(
             review_request_path(),
             {
                 "batch_id": REVIEW_QUEUE_ID,
                 "project": project,
-                "count": pending_count,
+                "count": pending,
                 "plan_path": dst,
                 "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
             },
@@ -336,7 +306,7 @@ def main() -> int:
 
     print(
         f"[merge_review_queue] merged {added} new draft(s) into {REVIEW_QUEUE_ID} "
-        f"({pending_count} pending total) from {os.path.basename(src)}",
+        f"({pending} pending total) from {os.path.basename(src)}",
         file=sys.stderr,
     )
     # Clean up the consumed batch plan so /tmp doesn't fill with orphans.

package/scripts/salvage_orphaned_prep_results.py

@@ -18,14 +18,10 @@ 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), 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.
+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.
 
 Usage:
     python3 scripts/salvage_orphaned_prep_results.py            # automated (safe age gate)
@@ -63,73 +59,15 @@ 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).
-
-    "reply_text" was the single-draft field before the 2026-07-07/08 two-draft
-    redesign (draft_a_text/draft_b_text per candidate, no single recommended
-    reply). Checking only "reply_text" made every post-redesign orphaned
-    result silently misclassified as non-prep and marked .skipped instead of
-    recovered — the exact "worker drafted but no card" bug this script exists
-    to prevent. Accept either field so both old and current schema results
-    are recognized.
-    """
+    """True iff obj looks like a twitter-prep result (candidates with reply_text)."""
     if not isinstance(obj, dict):
         return False
     cands = obj.get("candidates")
     if not isinstance(cands, list) or not cands:
         return False
     c0 = cands[0]
-    if not isinstance(c0, dict):
-        return False
-    has_text = "reply_text" in c0 or "draft_a_text" in c0
-    return has_text and ("candidate_url" in c0 or "candidate_id" in c0)
+    return isinstance(c0, dict) and "reply_text" in c0 and ("candidate_url" in c0 or "candidate_id" in c0)
 
 
 def main():
@@ -192,7 +130,6 @@ 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 "

package/skill/run-twitter-cycle.sh

@@ -734,12 +734,14 @@ ENGAGED_COUNT=$(echo "$ENGAGED_TWEET_IDS" | python3 -c 'import json,sys; print(l
 log "Recently-engaged tweet IDs loaded: $ENGAGED_COUNT (last 48h; scanner will skip them)"
 
 
-# --- Phase 1: deterministic query bank, scrapes tweets ----------------------
-# No Claude call (removed 2026-07-08; see the query-bank comment below). The
-# Python pipeline runs each banked query via headless Chrome and writes the
-# tweets directly to SCAN_TWEETS_FILE for the shell.
-
-log "Acquiring twitter-browser lock for Phase 1 scan..."
+# --- Phase 1: Claude drafts queries, scrapes tweets -------------------------
+# JSON schema forces structured output. Eliminates the prose-drift failure mode
+# Lean Phase 1 schema (2026-05-28): the scan session no longer scrapes,
+# it only drafts queries. The Python pipeline runs each query via headless
+# Chrome and writes the tweets directly to SCAN_TWEETS_FILE for the shell.
+SCAN_SCHEMA_LEAN='{"type":"object","properties":{"queries":{"type":"array","items":{"type":"object","properties":{"project":{"type":"string"},"query":{"type":"string"},"search_topic":{"type":"string"}},"required":["project","query","search_topic"]}}},"required":["queries"]}'
+
+log "Acquiring twitter-browser lock for Phase 1 Claude scan..."
 acquire_lock "twitter-browser" 3600 2>>"$LOG_FILE"
 log "twitter-browser lock held (pid=$$) Phase 1"
 # Drop stale Chrome singleton symlinks before launch. Background ungraceful-
@@ -909,15 +911,16 @@ log "  Pre-flight access OK: $(printf '%s' "$_ACCESS_OUT" | tr '\n' ' ' | tr -s
 # cap is hit before target, proceed with whatever we have (even 1 candidate
 # is better than 0). When BATCH_COUNT is still 0 after the loop, the
 # post-loop empty_batch branch fires.
-# Phase 1 is the deterministic qualified-query bank (no Claude): the bank
-# replays every historically qualified query for the picked project in a
+# DEFAULT Phase 1 is the deterministic qualified-query bank (no Claude): the
+# bank replays every historically qualified query for the picked project in a
 # single pass, so there is nothing to "retry-draft" and one attempt is enough.
-# (The old LLM-draft path used a 5-attempt retry loop, because LLM-drafted
-# queries frequently returned empty and needed re-drafting; removed 2026-07-08
-# — unused since the bank became the default 2026-05-28, and the queue-routed
-# claude call it made held the twitter-browser lock for no reason, the same
-# class of bug fixed in Phase 2b-prep the same day.)
-MAX_SCAN_ATTEMPTS=1
+# The legacy LLM-draft path (TWITTER_PHASE1_LLM_DRAFT=1) keeps the 5-attempt
+# retry loop, because LLM queries frequently return empty and need re-drafting.
+if [ "${TWITTER_PHASE1_LLM_DRAFT:-0}" = "1" ]; then
+    MAX_SCAN_ATTEMPTS=5
+else
+    MAX_SCAN_ATTEMPTS=1
+fi
 RETRY_TARGET=5
 SCAN_ATTEMPT=0
 BATCH_COUNT=0
@@ -1070,8 +1073,110 @@ export SCAN_TWEETS_FILE
 # Output downstream is identical: $RAW_FILE + $QUERIES_FILE feed the scorer
 # and twitter_search_attempts logger the same way as before.
 #
-# === DETERMINISTIC QUALIFIED-QUERY-BANK PATH (default since 2026-05-28;
-# only path since 2026-07-08 removal of the LLM query-draft alternative) =====
+if [ "${TWITTER_PHASE1_LLM_DRAFT:-0}" = "1" ]; then
+# === LLM QUERY-DRAFT PATH (legacy, behind TWITTER_PHASE1_LLM_DRAFT=1) ========
+log "Lean Phase 1: drafting queries (no browser tools)..."
+
+QUERIES_OUTPUT=$("$REPO_DIR/scripts/run_claude.sh" "run-twitter-cycle-queries" --strict-mcp-config --mcp-config "$TW_MCP_CONFIG" -p --output-format json --json-schema "$SCAN_SCHEMA_LEAN" "${TW_ENGINE_PREFIX}You are a Twitter query drafter. Your ONLY job is to draft fresh X advanced-search queries that surface tweets relevant to our projects. You do NOT post, you do NOT call any tools, you do NOT scrape. A separate Python pipeline runs your queries over the same CDP-driven Chrome and applies a strict freshness gate; you only return the query strings.
+
+## Step 1: Draft one search query per project
+
+You have $(echo "$PROJECTS_JSON" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)))') projects. Draft exactly ONE Twitter search query for each, tailored to that project's ASSIGNED search_topic.
+
+Each project entry carries TWO fields that drive your behavior: \`topic_picked_mode\` (either \`use\` or \`explore_invent\`) and \`search_topic\` (a string in \`use\` mode, NULL in \`explore_invent\` mode).
+
+USE mode (~90% of cycles, indicated by \`topic_picked_mode: \"use\"\` and a non-null \`search_topic\`):
+The Python picker has already chosen this project's search_topic by weighted-random sampling over the FULL universe in config.json. Your job is to translate that ASSIGNED topic into the best Twitter advanced-search query that will surface fresh, on-topic tweets. Do NOT substitute a different topic; do NOT paraphrase the topic. End-to-end attribution joins on the exact string.
+
+EXPLORE_INVENT mode (~10% of cycles, indicated by \`topic_picked_mode: \"explore_invent\"\` and \`search_topic: null\`):
+The picker is asking you to INVENT a brand-new search_topic. Look at the project's own \`reference_topics\` array and propose ONE new topic concept that does NOT appear there and is NOT a paraphrase of anything in it. Use your invented topic as the query's \`search_topic\` AND drive the keyword phrasing from it (one consistent string per project).
+
+Projects:
+$PROJECTS_JSON
+
+Top past queries FOR THE PROJECT YOU'RE DRAFTING FOR (7-day window, per-project, sorted by clicks DESC first, then composite-scored: clicks×100 + likes + views×0.001). CLICKS ARE THE PRIORITY SIGNAL. Each row carries THREE labels that tell you what to do with it as a reference:
+
+  - \`supply_bucket\`: low (<1 tweet/attempt), medium (1-5), high (>5). Raw supply X returned for this phrasing.
+  - \`conversion_bucket\`: low (<0.2 post_rate), medium (0.2-0.6), high (>=0.6). How often a found tweet survived the draft gate.
+  - \`guidance\`: one of MIMIC, KEEP_STYLE, NARROW, BROADEN — the action to take when drawing from this query.
+  - \`posts_per_attempt\`: posts produced per Phase 1 search invocation; <0.1 means most attempts produce zero survivors.
+
+How to act on \`guidance\`:
+  - MIMIC      — gold tier. Reuse the operator skeleton verbatim, swap only the topic keyword for the picker-assigned topic.
+  - KEEP_STYLE — solid. Use the operator pattern as inspiration; small phrasing tweaks OK.
+  - NARROW     — high supply, low conversion (noisy pond). If you draw from it, ADD specificity: more OR alternates, stricter min_faves, extra -term excludes.
+  - BROADEN    — low supply (query dying or topic running dry). The OPERATORS are dead weight. Shorten to 1-2 keywords, drop OR groups, step min_faves down a tier. Do NOT inherit operators from a BROADEN-tagged row.
+
+The canonical source for \`min_faves:N\` selection is the PER-PROJECT SUPPLY SIGNAL block below.
+$TOP_QUERIES_PER_PROJECT_JSON
+
+TOP-PERFORMING SEARCH TOPICS (conceptual seeds, 14d window) — context for query phrasing only; you draft a query for the picker-assigned topic, you do NOT swap topics here:
+$TOP_TOPICS_JSON
+
+DUD QUERIES — DO NOT REUSE these phrasings or close variants. They returned ZERO tweets in the last 48h:
+$DUD_QUERIES_JSON
+
+DUD CONCEPT SEEDS — these search_topic seeds pulled in tweets that Phase 2b's draft gate kept skipping over the last 7d. Per entry: \`omit_rate\` = skipped_n / (posted_n + skipped_n), \`sample_skip_reasons\` are the top reject reasons. If \`omit_rate >= 0.6\` AND \`skipped_n >= 5\`, REWORD the query narrower or drop the seed and pick a different config.json seed for that project:
+$DUD_TOPICS_JSON
+
+PER-PROJECT SUPPLY SIGNAL — for each project, the historical median tweets_found at each \`min_faves:N\` tier you've drafted in the last 14d. Pick the LOWEST tier where \`median_tweets_found >= 3\`; if every tier is below 3, drop one tier lower than the lowest you've tried. Trust this table over priors:
+$SUPPLY_SIGNAL_JSON
+
+ALREADY-ENGAGED TWEET IDS (last 48h) — the Python scraper skips these regardless, but knowing them helps you avoid drafting a query that would predominantly surface dead candidates:
+$ENGAGED_TWEET_IDS
+
+THIS-CYCLE QUERIES ALREADY TRIED with per-query outcomes (attempt $SCAN_ATTEMPT/$MAX_SCAN_ATTEMPTS, target=$RETRY_TARGET candidates after filters). Do NOT repeat any of these phrasings or close variants. Read each entry's \`verdict\` field and respond directionally (do NOT default to generic "broaden"):
+- \`dead_supply\` (raw_tweets=0): the phrasing returned ZERO tweets from X. The query was too narrow for X's index. HARD RULE: attempt N+1 MUST execute at least ONE of these THREE concrete broadening moves, NOT a topic rotation. Pick exactly one and apply it visibly: (a) lower \`min_faves\` by ONE FULL TIER (e.g. 20→5, 5→1, 1→0); (b) reduce the OR alternates inside any parenthesized group to AT MOST 2 terms (e.g. \`(A OR B OR C OR D)\` → \`(A OR B)\`); (c) drop ALL \`-term\` excludes EXCEPT those listed in this project's \`excludes_for_search\` (which remain mandatory). The PER-PROJECT SUPPLY SIGNAL block is OVERRIDDEN by \`dead_supply\` THIS CYCLE — do not appeal to historical min_faves when the current attempt returned 0. Swapping the topic noun while keeping the same operator skeleton is NOT broadening and is FORBIDDEN as a response to \`dead_supply\`.
+- \`all_aged_out\` (raw>0, kept_after_age=0): topic is supply-limited at the current freshness window; every tweet was older than the cap. Pick a structurally adjacent topic; do NOT rephrase the same one (it will just hit the cap again).
+- \`all_engaged_or_skipped\` (kept_after_age>0, kept_after_skip=0): query phrasing is fine, but the surviving tweets were already engaged on prior cycles. Pick a DIFFERENT topic, not a rephrase.
+- \`found_some\` (kept_after_skip>0 but below target): query is on-target. Raise min_faves one tier OR add a semantic constraint to lift quality. Do NOT broaden.
+$TRIED_QUERIES_JSON
+
+Query guidelines:
+- MANDATORY: do NOT add any date or time-window operator to your query (no \`since:\`, \`until:\`, \`since_time:\`, \`until_time:\`). The Python scraper enforces the freshness window at the URL level after you return; any time operator you include is stripped and overwritten. Including raw bash arithmetic, format strings, or placeholder text in place of a real epoch will be sent to X as a literal keyword and produce zero results.
+- MANDATORY EVEN IF YOUR QUERY KEYWORDS DO NOT NAME THE EXCLUDED TOPIC: if a project's \`excludes_for_search\` array is non-empty, append \`-term\` for EVERY listed term to that project's query, verbatim, no exceptions.
+- MANDATORY: pick \`min_faves:N\` per the PER-PROJECT SUPPLY SIGNAL above. If a project has no entry there (new / first cycle), start at min_faves:20.
+- Favor discussions/opinions (people sharing experience, asking questions), not news/promos/giveaways.
+- Pick a query likely to surface tweets RELEVANT to that project's actual domain.
+- Mix it up each run; don't always use the same query for the same project.
+- Use the project's ASSIGNED \`search_topic\` plus its \`description\` as grounding for query phrasing.
+- The \`search_topic\` you emit in the output JSON MUST be the project's assigned \`search_topic\` field pasted VERBATIM (NOT the query string, NOT a paraphrase). The scoring pipeline stamps \`twitter_candidates.search_topic\` from this for end-to-end attribution.
+
+## Output
+
+Return ONLY the structured_output JSON with this shape:
+{\"queries\": [{\"project\": \"PROJECT_NAME\", \"query\": \"X advanced search string with operators\", \"search_topic\": \"assigned or invented topic, verbatim\"}, ...]}
+
+One entry per project. Do NOT include tweets, do NOT include tweets_found, do NOT call any tool, do NOT scrape. The shell pipeline runs each query via headless Chrome with a strict freshness gate after you return." 2>&1)
+
+
+# Dump the captured envelope to the cycle log for offline inspection.
+echo "$QUERIES_OUTPUT" >> "$LOG_FILE"
+
+# Extract the drafted queries to a temp file.
+QUERIES_TMP="/tmp/twcycle-${BATCH_ID}-attempt-${SCAN_ATTEMPT}-queries.json"
+python3 -c "
+import json, sys
+text = sys.stdin.read().strip()
+try:
+    env, _ = json.JSONDecoder().raw_decode(text)
+except Exception as e:
+    print(f'lean phase 1: envelope parse error: {e}', file=sys.stderr)
+    json.dump([], open('$QUERIES_TMP', 'w'))
+    sys.exit(0)
+so = env.get('structured_output')
+if so is None:
+    so = env.get('result')
+if isinstance(so, str):
+    try: so = json.loads(so)
+    except Exception: pass
+qs = so.get('queries', []) if isinstance(so, dict) else []
+json.dump(qs, open('$QUERIES_TMP', 'w'))
+print(f'lean phase 1: drafted {len(qs)} queries', flush=True)
+" <<< "$QUERIES_OUTPUT" 2>&1 | tee -a "$LOG_FILE"
+
+else
+# === DETERMINISTIC QUALIFIED-QUERY-BANK PATH (default, 2026-05-28) ==========
 # No Claude call. Replay every historically qualified query for the picked
 # project(s): every distinct query that ever produced a posted reply with
 # >=1 like OR >=1 non-bot link click, regardless of the per-cycle
@@ -1087,6 +1192,7 @@ else
     log "Phase 1 (bank): building qualified query bank from PROJECTS_JSON (deterministic, no Claude)..."
     echo "$PROJECTS_JSON" | python3 "$REPO_DIR/scripts/qualified_query_bank.py" --from-projects-json > "$QUERIES_TMP" 2>>"$LOG_FILE"
 fi
+fi
 
 QUERIES_COUNT=$(python3 -c "
 import json