@m13v/s4l 1.7.2-rc.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);
     });

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.2-rc.1",
-  "installedAt": "2026-07-09T01:04:07.949Z"
+  "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.2-rc.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

@@ -1600,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
@@ -1832,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."""
@@ -1844,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

@@ -785,19 +785,12 @@ 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."""
-        _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
+        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",
@@ -1147,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
@@ -2509,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 = (
@@ -2530,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).
@@ -2585,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:
@@ -2615,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).
@@ -2623,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")
@@ -2881,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.
@@ -2986,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 = []
 
@@ -3008,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
@@ -3083,7 +3171,16 @@ class S4LMenuBar(rumps.App):
                 except Exception:
                     pass
                 if can_selfheal:
-                    items.append(rumps.MenuItem("Finish setting up drafts", callback=self._finish_schedule_setup))
+                    # 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)
@@ -3093,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
@@ -3103,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(
@@ -3132,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
@@ -3159,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.
@@ -3244,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.2-rc.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.2-rc.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",

package/scripts/claude_job.py

@@ -60,7 +60,6 @@ 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
@@ -75,11 +74,10 @@ TAG_TO_TYPE = {
 }
 
 # queue type -> (activity state, label) the menu bar shows while the job is in
-# 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.
+# 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.
 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,16 +129,31 @@ STATS_KEYS = (
 )
 
 
-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]
+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]
     try:
         sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
         from http_api import api_get
@@ -149,17 +164,24 @@ def _enrich_with_stats(cands: list) -> 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] stats enrichment skipped: {e}", file=sys.stderr)
-        return 0
+        print(f"[merge_review_queue] backend sync skipped: {e}", file=sys.stderr)
+        return 0, 0
     by_url = {str(r.get("tweet_url")): r for r in rows if r.get("tweet_url")}
     stamped = 0
-    for c in want:
+    pruned = 0
+    for c in pending:
         row = by_url.get(_thread_url(c))
         if not row:
             continue
-        c["stats"] = {k: row.get(k) for k in STATS_KEYS}
-        stamped += 1
-    return stamped
+        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
 
 
 def main() -> int:
@@ -255,9 +277,15 @@ def main() -> int:
         merged.append(c)
         added += 1
 
-    stamped = _enrich_with_stats(merged)
+    stamped, pruned = _sync_with_backend(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:
@@ -274,15 +302,17 @@ def main() -> int:
         _atomic_write(dst, plan_obj)
         ensure_store_symlink()
 
-        # 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")])
+        # 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")])
         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": pending_count,
                 "plan_path": dst,
                 "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
             },
@@ -306,7 +336,7 @@ def main() -> int:
 
     print(
         f"[merge_review_queue] merged {added} new draft(s) into {REVIEW_QUEUE_ID} "
-        f"({pending} pending total) from {os.path.basename(src)}",
+        f"({pending_count} 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/run_claude.sh

@@ -321,16 +321,22 @@ EOF
         # Dead-man's-switch (2026-07-09): every non-queue-routed tag (reddit,
         # linkedin, github, moltbook, instagram, dm-outreach-*, ...) blocks
         # here exactly like claude_job.py's queue provider does, with the
-        # same silent-death risk (SIGKILL/OOM/hard crash while waiting). Arm
-        # per-attempt (job id includes $CLAUDE_PG so a retry never collides
-        # with a still-unwinding prior attempt's watcher); disarm right after
-        # `wait` returns AND from _sa_cleanup's trap (that path SIGKILLs
-        # $CLAUDE_PG itself as ordinary TERM/INT/HUP handling, which must
-        # disarm too or a normal watchdog-triggered shutdown would misreport
-        # as an unexpected death). See scripts/producer_deathwatch.py.
+        # same silent-death risk (SIGKILL/OOM/hard crash while waiting).
+        # Watches THIS SCRIPT's own pid ($$), not $CLAUDE_PG: if only the
+        # claude child dies, `wait` unblocks normally and this script keeps
+        # running (RC-checked, logged, retried) — no observability gap.
+        # The gap is when the WHOLE TREE (this script included) is killed
+        # together, which is what actually happened in the salvage-orphan
+        # cases this was built for. Arm per-attempt (job id includes
+        # $CLAUDE_PG so a retry never collides with a still-unwinding prior
+        # attempt's watcher); disarm right after `wait` returns AND from
+        # _sa_cleanup's trap (that path SIGKILLs $CLAUDE_PG's group as
+        # ordinary TERM/INT/HUP handling, which must disarm too or a normal
+        # watchdog-triggered shutdown would misreport as an unexpected
+        # death). See scripts/producer_deathwatch.py.
         _SA_DW_JOB="${SESSION_ID}-${CLAUDE_PG}"
         python3 "$REPO_DIR/scripts/producer_deathwatch.py" arm \
-            --watch-pid "$CLAUDE_PG" --job-id "$_SA_DW_JOB" --qtype "$SCRIPT_TAG" \
+            --watch-pid "$$" --job-id "$_SA_DW_JOB" --qtype "$SCRIPT_TAG" \
             --batch "${BATCH_ID:-${SA_CYCLE_ID:--}}" --call-path direct \
             >/dev/null 2>&1 || true
         wait "$CLAUDE_PG"

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,15 +63,73 @@ 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 (candidates with reply_text)."""
+    """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.
+    """
     if not isinstance(obj, dict):
         return False
     cands = obj.get("candidates")
     if not isinstance(cands, list) or not cands:
         return False
     c0 = cands[0]
-    return isinstance(c0, dict) and "reply_text" in c0 and ("candidate_url" in c0 or "candidate_id" in c0)
+    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)
 
 
 def main():
@@ -130,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 "

package/skill/run-twitter-cycle.sh

@@ -734,14 +734,12 @@ 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: 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..."
+# --- 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..."
 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-
@@ -911,16 +909,15 @@ 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.
-# DEFAULT Phase 1 is the deterministic qualified-query bank (no Claude): the
-# bank replays every historically qualified query for the picked project in a
+# 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 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
+# (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
 RETRY_TARGET=5
 SCAN_ATTEMPT=0
 BATCH_COUNT=0
@@ -1073,110 +1070,8 @@ 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.
 #
-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) ==========
+# === DETERMINISTIC QUALIFIED-QUERY-BANK PATH (default since 2026-05-28;
+# only path since 2026-07-08 removal of the LLM query-draft alternative) =====
 # 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
@@ -1192,7 +1087,6 @@ 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