@m13v/s4l 1.7.2-rc.4 → 1.7.2-rc.6

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.2-rc.4",
-  "installedAt": "2026-07-09T01:35:07.203Z"
+  "version": "1.7.2-rc.6",
+  "installedAt": "2026-07-09T01:53:09.637Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.2-rc.4",
+  "version": "1.7.2-rc.6",
   "description": "Draft, review, approve, and autopilot X/Twitter posts.",
   "long_description": "## **⚠️ The disclaimer above is generic Claude boilerplate.** Anthropic shows the same warning on every plugin regardless of what it does; any plugin has the same level of access as any app you download from the internet.\n\nS4L is an open source product developed by Mediar.ai Incorporated, a VC-backed San Francisco-based startup.\n\nTo get started:\n\n1\\. Copy this prompt: **Set me up on S4L plugin end to end**\n\n2\\. Quit with CMD+Q, reopen Claude, paste into a new chat.\n\nWhat happens next:\n\n* About every 5 minutes S4L scans X for posts that match your topics and drafts replies in your voice.\n* Drafts show up as review cards, usually the first within a few minutes. Nothing is posted automatically; you approve each one.\n* Posting autopilot stays off until you explicitly turn it on.",
   "author": {

package/mcp/menubar/s4l_card.py

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

package/mcp/menubar/s4l_menubar.py

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

package/mcp/menubar/s4l_state.py

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

package/mcp/package.json

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