@m13v/s4l 1.7.6-rc.32 → 1.7.6-rc.34

package/README.md

@@ -157,7 +157,7 @@ The plugin exposes MCP tools for the user-facing workflow:
 - `project_config` configures projects, products, voice, topics, and X auth.
 - `engagement_mode` chooses personal-brand and product-promotion lanes.
 - `dashboard` opens the review dashboard.
-- `post_drafts` posts only the drafts the user selected.
+- `approve_drafts` posts only the drafts the user selected.
 - `get_stats` reads X/Twitter stats.
 - `pause_s4l` pauses or resumes scheduled S4L jobs.
 - `runtime` installs, updates, and diagnoses the local runtime.

package/mcp/dist/index.js

@@ -6,7 +6,7 @@
 //                     via the host create_scheduled_task. The autopilot then drafts
 //                     on its own (launchd kicker + queue worker); there is no manual
 //                     "draft now" tool.
-//   post_drafts     - post the drafts the user chose by number from a batch.
+//   approve_drafts     - post the drafts the user chose by number from a batch.
 //   get_stats    - read-only post + engagement stats.
 //
 // THIN wrapper. The pipeline brain (scan, score, drafting prompts, posting)
@@ -37,7 +37,7 @@ const PANEL_URI = "ui://social-autoposter/panel.html";
 const PRODUCT_LINK_URI = "ui://social-autoposter/product-link.html";
 // Stable id for the accumulating draft review queue. Each draft cycle appends its
 // drafts here (dedup by tweet URL) so the menu-bar cards PILE UP across a
-// continuous autopilot instead of each run overwriting the last; post_drafts posts
+// continuous autopilot instead of each run overwriting the last; approve_drafts posts
 // the approved subset and marks them posted (filtered out of the cards thereafter).
 const REVIEW_QUEUE_ID = "review-queue";
 // ---- Queue-backed drafting (2026-06-23) -----------------------------------
@@ -397,12 +397,12 @@ const server = new McpServer({
         "(configure the product project) -> `queue_setup` + " +
         "`create_scheduled_task` (set up the draft autopilot once) -> the autopilot then runs on its own " +
         "(scans, drafts via the queue + worker, and merges into the approval cards; nothing posts) -> the " +
-        "user approves in the menu bar -> `post_drafts` (post the approved ones) -> `get_stats` (see " +
+        "user approves in the menu bar -> `approve_drafts` (post the approved ones) -> `get_stats` (see " +
         "performance). Run `project_config` first; the other tools refuse until a " +
         "project is fully configured. To change anything about a project later, call `project_config` " +
         "again with the project's name and just the changed fields — there is no separate config editor.\n\n" +
         "RENDER THE DASHBOARD AFTER ACTIONS. After any state-changing or results-producing tool call " +
-        "(`post_drafts`, `get_stats`, `project_config`), end your turn by " +
+        "(`approve_drafts`, `get_stats`, `project_config`), end your turn by " +
         "calling the `dashboard` tool so the user sees the updated state visually. Do NOT call " +
         "`dashboard` after pure Q&A, config explanations, or status-only checks that changed nothing.\n\n" +
         "REPORT FIELD DIAGNOSES. Whenever an S4L setup, healing, or troubleshooting flow FAILS, or " +
@@ -421,7 +421,7 @@ const baseRegisterTool = server.registerTool.bind(server);
 // show a spinner + label while they run (either invocation path). draft_cycle is
 // NOT here — it writes finer scanning/drafting phases itself (see produceDrafts).
 const TOOL_ACTIVITY = {
-    post_drafts: "posting",
+    approve_drafts: "posting",
     get_stats: "stats…",
 };
 function toolActivityLabel(name, args) {
@@ -748,7 +748,7 @@ async function produceDrafts(project, onProgress) {
 }
 // Render every draft in a batch as a numbered, human-readable table. This IS the
 // review surface now: the model relays this table to the user and asks which
-// numbers to post / edit, then posts the chosen ones via the `post_drafts` tool.
+// numbers to post / edit, then posts the chosen ones via the `approve_drafts` tool.
 //
 // We used to gather approvals through MCP elicitation (a checkbox form), but the
 // desktop "Code tab" host doesn't advertise the `elicitation` capability (only
@@ -757,7 +757,7 @@ async function produceDrafts(project, onProgress) {
 function renderDraftsTable(plan) {
     const candidates = plan.candidates || [];
     return candidates
-        // Number by FULL-array index (matches post_drafts + the menu bar), then drop
+        // Number by FULL-array index (matches approve_drafts + the menu bar), then drop
         // already-finished entries so the cards only show what's still pending.
         .map((c, i) => ({ c, n: i + 1 }))
         // awaiting_review is the ONLY state the review surfaces present (same rule
@@ -773,7 +773,7 @@ function renderDraftsTable(plan) {
         const reply = c.reply_text ?? "(empty)";
         // The literal tail URL is NOT known yet: at post time a short link is minted
         // from this target (e.g. fazm.ai/cc -> s4l.ai/r/<code>). Approved drafts
-        // always carry the link (post_drafts forces TWITTER_TAIL_LINK_RATE=1.0), so
+        // always carry the link (approve_drafts forces TWITTER_TAIL_LINK_RATE=1.0), so
         // this is the target that WILL be appended. Show the TARGET only; never
         // pre-mint the real /r/ code (that would waste pool codes / split clicks).
         const link = c.link_url
@@ -1126,7 +1126,7 @@ async function postApproved(batchId, plan) {
                 attempted: 0,
                 exit_code: 0,
                 summary: "another posting drain has been running for 8+ minutes; approved cards stay " +
-                    "queued in the review store — re-run post_drafts once it finishes",
+                    "queued in the review store — re-run approve_drafts once it finishes",
             };
         }
         if (waited) {
@@ -1255,7 +1255,7 @@ async function postApproved(batchId, plan) {
                         redditFailed++;
                         continue;
                     }
-                    // The card's reply_text is the CANONICAL text (post_drafts edits write
+                    // The card's reply_text is the CANONICAL text (approve_drafts edits write
                     // there); the embedded decision still carries the draft-time original.
                     // Posting dec.text verbatim would silently discard a human edit.
                     const decPost = {
@@ -1329,7 +1329,7 @@ async function postApproved(batchId, plan) {
                     }
                     else {
                         // Leave the approval sticky (approved && !posted && !terminal) so the
-                        // next post_drafts call retries, mirroring twitter's failed-drain
+                        // next approve_drafts call retries, mirroring twitter's failed-drain
                         // semantics; only stamp terminal on a conclusive CDP refusal. This
                         // list MUST stay a superset of post_reddit.py's own
                         // _PERMANENT_CDP_ERRORS (account_blocked_in_sub, no_permalink) —
@@ -1433,7 +1433,7 @@ async function postApproved(batchId, plan) {
         // we can write our own pid) — a pathological edge case, not the normal path.
         // Bail out rather than proceed without ever confirming we hold it. Approved
         // cards stay sticky (approved && !posted && !terminal), so the very next
-        // post_drafts call — the next approval, or this same tool retried — picks
+        // approve_drafts call — the next approval, or this same tool retried — picks
         // them straight back up; nothing is lost or re-queued.
         postingActive = false;
         stopPostingFlagHeartbeat();
@@ -1441,7 +1441,7 @@ async function postApproved(batchId, plan) {
             attempted: 0,
             exit_code: 0,
             summary: "couldn't pin down the twitter-browser lock after repeated attempts; approved cards " +
-                "stay queued — re-run post_drafts to retry",
+                "stay queued — re-run approve_drafts to retry",
         };
     }
     const approvedBatch = `${batchId}_approved`;
@@ -1497,9 +1497,9 @@ async function postApproved(batchId, plan) {
                     // are now no-ops for the normal path — every approved candidate
                     // already carries tail_link_variant by the time it reaches this MCP
                     // tool. They're left in place as a defense-in-depth fallback for the
-                    // rare case a candidate reaches post_drafts unstamped (e.g. a plan
+                    // rare case a candidate reaches approve_drafts unstamped (e.g. a plan
                     // already in flight from before this change): S4L_SKIP_LINK_TAIL=1
-                    // still guarantees post_drafts (a synchronous call the user is
+                    // still guarantees approve_drafts (a synchronous call the user is
                     // waiting on) never makes a blocking Claude/queue call at post time,
                     // no matter what.
                     TWITTER_TAIL_LINK_RATE: "1.0",
@@ -1541,7 +1541,7 @@ async function postApproved(batchId, plan) {
         const postLogDir = path.join(repoDir(), "skill", "logs");
         fs.mkdirSync(postLogDir, { recursive: true });
         const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-        fs.writeFileSync(path.join(postLogDir, `post-${stamp}.log`), `# post_drafts batch=${batchId} approved=${approvedTwitter.length} exit=${res.code} ` +
+        fs.writeFileSync(path.join(postLogDir, `post-${stamp}.log`), `# approve_drafts batch=${batchId} approved=${approvedTwitter.length} exit=${res.code} ` +
             `shell_lock=${heldShellLock}\n\n=== stdout ===\n${res.stdout}\n\n=== stderr ===\n${res.stderr}\n`);
     }
     catch {
@@ -1620,7 +1620,7 @@ async function postApproved(batchId, plan) {
                 // ... waited 45s, giving up."). None of those mean the draft is
                 // doomed, only that this attempt didn't get a turn with the shared
                 // browser. Leave the card sticky (approved && !posted && !terminal)
-                // so the next post_drafts call retries it, mirroring Reddit's
+                // so the next approve_drafts call retries it, mirroring Reddit's
                 // _TRANSIENT_CDP_ERRORS handling. Unconditionally marking terminal
                 // here (found 2026-07-16) silently and permanently discarded 7 real
                 // approved drafts on nothing worse than lock contention — Reddit's
@@ -1673,7 +1673,7 @@ async function postApproved(batchId, plan) {
     // actionable error on its own.
     const hasRealFailure = res.code !== 0 || Boolean(summObj?.failure_reasons);
     if (hasRealFailure) {
-        captureError(new Error(`post_drafts: ${realPosted}/${approvedTwitter.length} posted (exit=${res.code})`), {
+        captureError(new Error(`approve_drafts: ${realPosted}/${approvedTwitter.length} posted (exit=${res.code})`), {
             component: "post",
             exit_code: String(res.code),
             attempted: String(approvedTwitter.length),
@@ -2863,11 +2863,11 @@ tool("project_config", {
         return textContent(`Setup failed: ${e.message}`);
     }
 });
-// ---- post_drafts: post the user's chosen drafts from a batch ---------------
+// ---- approve_drafts: post the user's chosen drafts from a batch ---------------
 // Second half of the manual loop. The user reviewed the menu-bar cards a draft
 // cycle produced and said which numbers to post / edit; this posts exactly those.
 // Editing a draft implies posting it. Indices are 1-based, matching the table.
-tool("post_drafts", {
+tool("approve_drafts", {
     title: "Post chosen drafts",
     description: "Post the drafts the user approved from a draft cycle. Pass the batch_id from the " +
         "approval cards and the user's decision by NUMBER (1-based, matching the table): `post` is " +
@@ -3054,7 +3054,7 @@ tool("post_drafts", {
     }
     // STICKY approve: record the approval DURABLY and never clear another card's
     // prior approval. The old `c.approved = approve.has(i+1)` reset every card on
-    // each call, so a later post_drafts for a different card dropped a
+    // each call, so a later approve_drafts for a different card dropped a
     // restart-interrupted approved card back into "pending". postApproved filters
     // posted/terminal, so the approved set only ever drains what's genuinely left.
     approve.forEach((n) => {
@@ -3092,7 +3092,7 @@ tool("post_drafts", {
         });
         storeWriteDone = await patchReviewStore(patches);
         if (!storeWriteDone)
-            console.error("[post_drafts] store_patch.py failed; falling back to unlocked plan write");
+            console.error("[approve_drafts] store_patch.py failed; falling back to unlocked plan write");
     }
     if (!storeWriteDone)
         writePlan(batch_id, plan);
@@ -4052,12 +4052,12 @@ function queueWorkerAllowedTools() {
         "Grep",
         // This server's tools, both namespaces (manifest name + protocol name).
         "mcp__social-autoposter__queue_setup",
-        "mcp__social-autoposter__post_drafts",
+        "mcp__social-autoposter__approve_drafts",
         "mcp__social-autoposter__project_config",
         "mcp__social-autoposter__get_stats",
         "mcp__social-autoposter__dashboard",
         "mcp__S4L__queue_setup",
-        "mcp__S4L__post_drafts",
+        "mcp__S4L__approve_drafts",
         "mcp__S4L__project_config",
         "mcp__S4L__get_stats",
         "mcp__S4L__dashboard",
@@ -4263,7 +4263,7 @@ function kickerEnv() {
         // The persona lane exports =0 per cycle via s4l_mode.py env (link-free
         // organic replies); promotion cycles keep the script's own default so
         // draft-only-OFF posts carry the project link per the A/B gate, and card posts
-        // still force =1.0 inside post_drafts.
+        // still force =1.0 inside approve_drafts.
         // Virality bar percentile is NOT set here: it is hardcoded to 0.90 in
         // skill/run-twitter-cycle.sh (single source of truth, no env dependency).
     };
@@ -5469,7 +5469,7 @@ function persistStatusSummary(snap) {
 // chat-table review path is unchanged and still works; this just ALSO lets the
 // corner cards drive review (both surfaces de-dup via the plan's `posted` flag).
 // The menu bar reads review-request.json, presents the cards, posts via the
-// loopback post_drafts tool, then clears the file. Best-effort: a write failure
+// loopback approve_drafts tool, then clears the file. Best-effort: a write failure
 // just means no pop-ups this batch (chat review still works).
 function writeReviewRequest(req) {
     try {
@@ -5653,7 +5653,7 @@ function sigkillAllScans() {
 }
 // ---- Lock grace-hold: hold the /tmp lock CONTINUOUSLY across per-card posts ----
 // The plist pipeline acquires the browser lock ONCE and holds it through the whole
-// posting phase. The MCP posts per approved card (separate post_drafts calls), and
+// posting phase. The MCP posts per approved card (separate approve_drafts calls), and
 // the old code acquired+released the lock PER CARD — leaving a release window
 // BETWEEN every card that a parked scan stale-reclaimed (the hijack). Instead we
 // keep the lock and only release it after SHELL_LOCK_GRACE_MS of no posting, so the
@@ -5808,7 +5808,7 @@ appTool("dashboard", {
         "connection, autopilot state, and 7-day stats, with buttons to set up the schedule, connect X, " +
         "and refresh. Use when the user asks to see the dashboard, panel, " +
         "status, or controls. ALSO call this at the end of any state-changing or results-producing " +
-        "action (post_drafts, get_stats, project_config) so the user sees the " +
+        "action (approve_drafts, get_stats, project_config) so the user sees the " +
         "updated dashboard. Hosts without UI support get the same data as text.",
     inputSchema: {},
     // fallback_url is set only when the host can't render the ui:// resource and

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.6-rc.32",
-  "installedAt": "2026-07-18T01:56:01.177Z"
+  "version": "1.7.6-rc.34",
+  "installedAt": "2026-07-18T02:38:17.233Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.6-rc.32",
+  "version": "1.7.6-rc.34",
   "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": {
@@ -33,7 +33,7 @@
       "description": "Configure or edit a project"
     },
     {
-      "name": "post_drafts",
+      "name": "approve_drafts",
       "description": "Post chosen drafts"
     },
     {

package/mcp/menubar/s4l_menubar.py

@@ -580,7 +580,7 @@ class S4LMenuBar(rumps.App):
         self._review_unattended_notified = False
         self._review_unattended_captured = False
         # This session's card decisions, for store reconciliation: the MCP
-        # server's post_drafts rewrites the whole review store from a copy read
+        # server's approve_drafts rewrites the whole review store from a copy read
         # before a minutes-long posting run, so a decision stamped mid-drain can
         # be clobbered; the tick re-stamps anything missing (_reconcile_store).
         self._session_decisions = []
@@ -1379,7 +1379,9 @@ class S4LMenuBar(rumps.App):
                 "S4L posting volume",
                 f"Posting volume: {self._posting_mode_label(stored)}. Applies from the next cycle.",
             )
-        except Exception as e:
+        except (Exception, SystemExit) as e:
+            # http_api raises SystemExit on terminal network failure; it must
+            # not escape a rumps menu callback.
             sys.stderr.write(f"[s4l-menubar] posting-mode write failed: {e}\n")
             sys.stderr.flush()
             self._notify(
@@ -2961,17 +2963,11 @@ class S4LMenuBar(rumps.App):
             else None,
             os.path.exists(PAUSE_FLAG),
             pending_count,
-            # Snooze end (0 = not snoozed): rebuilds the menu when a snooze is
-            # set, cleared, or lapses, so the "Snoozed until HH:MM" label and
-            # the review item stay honest.
-            int(self._review_snooze_until)
-            if time.time() < self._review_snooze_until
-            else 0,
             # Reveal cadence: rebuilds when the preset changes (checkmark +
-            # submenu title) and when a hold starts or lapses (the "Next cards
-            # around HH:MM" line in _state_c).
+            # submenu title). The snooze-end and reveal-hold rebuild triggers
+            # were dropped with the _state_c courtesy sublines they drove
+            # (2026-07-17) — nothing visible depends on them anymore.
             round(st.read_reveal_cadence()),
-            int(self._reveal_hold_until(pending_count)),
             # View mode: rebuilds when the review layout changes (checkmark
             # in the "View Mode" submenu + whether the cadence item shows).
             st.read_review_layout(),
@@ -3018,7 +3014,7 @@ class S4LMenuBar(rumps.App):
     def _posting_activity_label_locked(self):
         """Progress for the current menu-bar approval burst.
 
-        The server receives one post_drafts call per approved card, so its native
+        The server receives one approve_drafts call per approved card, so its native
         view is always 1/1. The menu bar owns the burst queue and can show the
         useful progress: current approved post / total approved so far.
         """
@@ -3495,7 +3491,7 @@ class S4LMenuBar(rumps.App):
 
             def _persist_reject():
                 try:
-                    st.post_drafts(batch, reject=[n], timeout=30)
+                    st.approve_drafts(batch, reject=[n], timeout=30)
                 except Exception:
                     pass
 
@@ -3615,7 +3611,7 @@ class S4LMenuBar(rumps.App):
 
         def _persist_discard():
             try:
-                st.post_drafts(batch, reject=ns, timeout=60)
+                st.approve_drafts(batch, reject=ns, timeout=60)
             except Exception:
                 pass
             try:
@@ -3750,7 +3746,7 @@ class S4LMenuBar(rumps.App):
     def _post_worker_loop(self):
         # Serialized poster: one approved card at a time so two posts never drive
         # the shared harness Chrome simultaneously. The menu bar passes a burst
-        # progress label into post_drafts, so the spinner shows e.g. "posting 17/95"
+        # progress label into approve_drafts, so the spinner shows e.g. "posting 17/95"
         # even though each server call is still one approved draft.
         while True:
             batch, decision = self._post_q.get()  # blocks until a card is approved
@@ -3767,7 +3763,7 @@ class S4LMenuBar(rumps.App):
                 # through edits=[...] even with no hand-typed change, so the
                 # candidate's style/assigned_style/assigned_mode switch to
                 # match whichever draft is actually posting (mcp/src/index.ts
-                # post_drafts applies both from the same entry). Without
+                # approve_drafts applies both from the same entry). Without
                 # this, a card where the human accepted the recommended
                 # draft as-is (edited=False) would still need its variant
                 # tag carried through for consistency with a later switch.
@@ -3776,19 +3772,19 @@ class S4LMenuBar(rumps.App):
                     edit = {"n": n, "text": decision.get("text") or ""}
                     if draft_variant:
                         edit["variant"] = draft_variant
-                    res = st.post_drafts(
+                    res = st.approve_drafts(
                         batch,
                         edits=[edit],
                         clear_link=cl,
                         activity_label=activity_label,
                     )
                 else:
-                    res = st.post_drafts(batch, post=[n], clear_link=cl, activity_label=activity_label)
+                    res = st.approve_drafts(batch, post=[n], clear_link=cl, activity_label=activity_label)
                 if res is None:
                     # Loopback unreachable (Claude closed, mid-restart, or an
                     # account switch tore down the old MCP server before a new
                     # one registered). Unlike a real posting failure, nothing
-                    # was ever attempted here — post_drafts never reached a
+                    # was ever attempted here — approve_drafts never reached a
                     # server — so there's no double-post risk in retrying.
                     # Deliberately do NOT call store_mark_post_failed: it would
                     # exclude this card from store_pending_posts(), which is
@@ -4192,9 +4188,10 @@ class S4LMenuBar(rumps.App):
             items.append(cadence_menu)
 
         # Posting volume: server-side per-install throttle (virality bar).
-        # read_posting_mode() is cached and non-blocking; unknown/unset shows
-        # as Steady (the server resolves unset the same way), corrected on the
-        # rebuild after the first refresh lands.
+        # read_posting_mode() is cached and non-blocking; the cache is seeded
+        # from the on-disk last-known copy at boot, so a restart keeps showing
+        # the user's chosen mode. Genuinely unset shows as Steady (the server
+        # resolves unset the same way), corrected after the first refresh.
         pv_mode = st.read_posting_mode() or "medium"
         pv_menu = rumps.MenuItem(
             f"Posting volume: {self._posting_mode_label(pv_mode).split(' (')[0].lower()}"
@@ -4370,47 +4367,21 @@ class S4LMenuBar(rumps.App):
         if pending_count <= 0:
             return []
         plural = "s" if pending_count != 1 else ""
-        items = [
+        # Just the clickable review item — no secondary grey subline. The old
+        # snooze / reveal-cadence courtesy lines ("Snoozed until…", "Next cards
+        # around…", "Cards hidden…", "Canvas opens from the review item above")
+        # were removed per user request (2026-07-17): "Review N pending drafts"
+        # opens them right now regardless of the pop-up pacing, so the extra line
+        # only restated the click behavior. The reveal-cadence + snooze controls
+        # still live in _build_menu; this just drops the redundant readout.
+        # No bulk-discard item here either: "Discard all…" lives in the review
+        # card's title bar (2026-07-10).
+        return [
             rumps.MenuItem(
                 f"Review {pending_count} pending draft{plural}",
                 callback=self._review_now,
             )
         ]
-        # The review-surface picker ("View Mode") lives in _build_menu now
-        # (2026-07-16): always visible, not just while something is pending.
-        if time.time() < self._review_snooze_until:
-            items.append(
-                self._label(
-                    "Snoozed until "
-                    + time.strftime(
-                        "%H:%M", time.localtime(self._review_snooze_until)
-                    )
-                )
-            )
-        else:
-            # Reveal-cadence hold: the backlog exists but the pop-up is being
-            # paced, or suppressed entirely ("Never"). Same courtesy line as
-            # the snooze; "Review N pending drafts" above shows them right
-            # now regardless.
-            hold_until = self._reveal_hold_until(pending_count)
-            if hold_until < 0:
-                if st.read_review_layout() == "cards":
-                    items.append(self._label("Cards hidden — see count in the menu bar"))
-                else:
-                    # Canvas mode: it never auto-opens; the review item above
-                    # is the one way in.
-                    items.append(self._label("Canvas opens from the review item above"))
-            elif hold_until:
-                items.append(
-                    self._label(
-                        "Next cards around "
-                        + time.strftime("%H:%M", time.localtime(hold_until))
-                    )
-                )
-        # No bulk-discard item here anymore: "Discard all…" lives in the
-        # review card's title bar (2026-07-10). Reaching it with no card open
-        # is "Review N pending drafts" -> Discard all, two clicks.
-        return items
 
 
 if __name__ == "__main__":

package/mcp/menubar/s4l_state.py

@@ -269,7 +269,7 @@ def autopilot_loaded() -> bool:
 # A machine with any system-wide proxy configured (corporate VPN client,
 # security software, a residential-IP proxy for platform fingerprinting,
 # etc.) whose bypass list doesn't happen to include 127.0.0.1/localhost will
-# have every loopback health check and post_drafts call silently routed out
+# have every loopback health check and approve_drafts call silently routed out
 # through that proxy instead of hitting the MCP server directly — surfacing
 # as an opaque connection error/403 with no indication the proxy is at
 # fault. This is a local process talking to its own local server: it must
@@ -534,7 +534,7 @@ def accessibility_trusted() -> bool:
 # draft_cycle writes review-request.json when a fresh batch is ready; we read
 # the linked plan file (the /tmp/twitter_cycle_plan_<batch>.json the pipeline
 # produced), present the cards, then post the approved subset via the loopback
-# post_drafts tool. The chat-table review still works in parallel; both surfaces
+# approve_drafts tool. The chat-table review still works in parallel; both surfaces
 # de-dup on the plan's per-candidate `posted` flag.
 # How long an activity signal may go un-refreshed before the menu bar treats it
 # as idle. This is the SELF-HEAL for a frozen spinner: a writer can set a label
@@ -585,7 +585,7 @@ def read_activity():
 def write_activity(state: str, label: str):
     """Best-effort local activity update. The MCP server normally owns this file,
     but the menu-bar posting queue knows the whole approved-card burst while the
-    server only sees one post_drafts call at a time."""
+    server only sees one approve_drafts call at a time."""
     try:
         p = Path(state_dir()) / "activity.json"
         p.parent.mkdir(parents=True, exist_ok=True)
@@ -928,7 +928,7 @@ def store_mark_post_failed(batch, n, candidate_id=None, error=None):
 
 def store_pending_posts(batch="review-queue"):
     """Approved-but-unposted candidates, for the restart resume path. Skips
-    posted/terminal/failed rows; each entry carries everything post_drafts
+    posted/terminal/failed rows; each entry carries everything approve_drafts
     needs (n, final text, drop_link)."""
     plan = read_plan(store_path())
     out = []
@@ -951,7 +951,7 @@ def store_pending_posts(batch="review-queue"):
 
 def store_reconcile_decisions(batch, decisions):
     """Re-stamp any of this session's decisions the store no longer shows. The
-    MCP server's post_drafts does a whole-file read-modify-write while a batch
+    MCP server's approve_drafts does a whole-file read-modify-write while a batch
     posts (minutes), so a decision stamped mid-drain can be clobbered by its
     stale rewrite; the menubar calls this every timer tick with its in-memory
     decision list so the store always converges back to what the user chose.
@@ -985,7 +985,7 @@ def review_queue_posted_count():
     """Posts that have LANDED in the review-queue plan — the durable, cross-process
     truth. Independent of the menu bar's in-memory burst queue (which dies on a
     restart) and of WHICH process is posting (the menu bar worker, the autopilot,
-    or a host agent draining via post_drafts). Returns the posted count, or None
+    or a host agent draining via approve_drafts). Returns the posted count, or None
     when the plan can't be read. Drives the menu-bar posting indicator so progress
     stays visible regardless of how the drain is driven."""
     plan_path = None
@@ -1022,7 +1022,7 @@ def review_drafts(plan, batch="review-queue"):
             continue
         out.append(
             {
-                "n": i + 1,  # 1-based, matches post_drafts numbering
+                "n": i + 1,  # 1-based, matches approve_drafts numbering
                 # Platform tag (reddit cards, 2026-07-14): absent/None means
                 # twitter (every plan written before the field shipped). The
                 # card renders the platform mark and profile link from this.
@@ -1336,7 +1336,10 @@ def _refresh_posting_mode():
         write_cached_mode(mode)
         with _posting_mode_lock:
             _posting_mode_cache.update(mode=mode, known=True, at=time.time())
-    except Exception as e:
+    except (Exception, SystemExit) as e:
+        # http_api raises SystemExit (not Exception) on terminal failure;
+        # catching only Exception let it kill this thread BEFORE the retry
+        # throttle below, so offline boxes hot-looped refresh attempts.
         sys.stderr.write(f"[s4l-state] posting-mode refresh failed: {e}\n")
         with _posting_mode_lock:
             # Throttle retries to the TTL window; keep last-known value.
@@ -1364,12 +1367,15 @@ def write_posting_mode(mode):
     r = api_post("/api/v1/installations/posting-mode", {"mode": mode})
     d = (r or {}).get("data") or {}
     stored = d.get("mode")
+    stored_valid = stored if stored in ("high", "medium", "low") else None
+    try:
+        from s4l_posting_mode import write_cached_mode
+
+        write_cached_mode(stored_valid)
+    except Exception:
+        pass
     with _posting_mode_lock:
-        _posting_mode_cache.update(
-            mode=stored if stored in ("high", "medium", "low") else None,
-            known=True,
-            at=time.time(),
-        )
+        _posting_mode_cache.update(mode=stored_valid, known=True, at=time.time())
     return stored
 
 
@@ -1388,7 +1394,7 @@ def toggle_lane(lane):
 # + store_pending_posts) is the only decision record and resume source now.
 
 
-def post_drafts(batch_id, post=None, edits=None, reject=None, clear_link=None, timeout=900, activity_label=None):
+def approve_drafts(batch_id, post=None, edits=None, reject=None, clear_link=None, timeout=900, activity_label=None):
     """Post / reject drafts via the loopback tool. `post` = 1-based numbers to post
     as-is; `edits` = [{n, text}] to rewrite then post; `reject` = numbers to mark
     DONE so they're never shown for review again (not posted); `clear_link` =
@@ -1398,7 +1404,7 @@ def post_drafts(batch_id, post=None, edits=None, reject=None, clear_link=None, t
     args = {"batch_id": batch_id, "post": post or [], "edits": edits or [], "reject": reject or [], "clear_link": clear_link or []}
     if activity_label:
         args["__s4l_activity_label"] = activity_label
-    return loopback_tool("post_drafts", args, timeout=timeout)
+    return loopback_tool("approve_drafts", args, timeout=timeout)
 
 
 # ---- review-events outbox (2026-07-02) --------------------------------------

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.6-rc.32",
+  "version": "1.7.6-rc.34",
   "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.6-rc.32",
+  "version": "1.7.6-rc.34",
   "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/github_tools.py

@@ -91,9 +91,10 @@ def _save_repo_gone_cache(cache):
 
 
 def _fetch_repo_state(owner, repo, _mem={}, _disk={"loaded": False, "data": {}}):
-    """Fetch and cache (gone, has_issues, has_discussions) for owner/repo.
-    Two-tier cache (in-process + 24h on-disk JSON). Returns a dict
-    {gone: bool, has_issues: bool, has_discussions: bool}."""
+    """Fetch and cache (gone, has_issues, has_discussions, stars) for
+    owner/repo. Two-tier cache (in-process + 24h on-disk JSON). Returns a dict
+    {gone: bool, has_issues: bool, has_discussions: bool, stars: int|None}.
+    stars is None when the repo payload was unavailable (404, network)."""
     key = f"{owner}/{repo}".lower()
     if key in _mem:
         return _mem[key]
@@ -103,11 +104,12 @@ def _fetch_repo_state(owner, repo, _mem={}, _disk={"loaded": False, "data": {}})
     entry = _disk["data"].get(key)
     now = int(time.time())
     if (entry and (now - int(entry.get("checked_at", 0))) < _REPO_GONE_TTL_SEC
-            and "has_issues" in entry):
+            and "has_issues" in entry and "stars" in entry):
         state = {
             "gone": bool(entry.get("gone")),
             "has_issues": bool(entry.get("has_issues", True)),
             "has_discussions": bool(entry.get("has_discussions", True)),
+            "stars": entry.get("stars"),
         }
         _mem[key] = state
         return state
@@ -117,7 +119,8 @@ def _fetch_repo_state(owner, repo, _mem={}, _disk={"loaded": False, "data": {}})
             capture_output=True, text=True, timeout=20,
         )
     except Exception:
-        state = {"gone": False, "has_issues": True, "has_discussions": True}
+        state = {"gone": False, "has_issues": True, "has_discussions": True,
+                 "stars": None}
         _mem[key] = state
         return state
     if proc.returncode == 0:
@@ -125,20 +128,27 @@ def _fetch_repo_state(owner, repo, _mem={}, _disk={"loaded": False, "data": {}})
             data = json.loads(proc.stdout or "{}")
         except Exception:
             data = {}
+        try:
+            stars = int(data.get("stargazers_count"))
+        except (TypeError, ValueError):
+            stars = None
         state = {
             "gone": False,
             "has_issues": bool(data.get("has_issues", True)),
             "has_discussions": bool(data.get("has_discussions", True)),
+            "stars": stars,
         }
     else:
         err = ((proc.stderr or "") + (proc.stdout or "")).lower()
         gone = ("not found" in err or "http 404" in err)
-        state = {"gone": gone, "has_issues": True, "has_discussions": True}
+        state = {"gone": gone, "has_issues": True, "has_discussions": True,
+                 "stars": None}
     _mem[key] = state
     _disk["data"][key] = {
         "gone": state["gone"],
         "has_issues": state["has_issues"],
         "has_discussions": state["has_discussions"],
+        "stars": state["stars"],
         "checked_at": now,
     }
     _save_repo_gone_cache(_disk["data"])

package/scripts/post_github.py

@@ -157,6 +157,10 @@ SKILL_FILE = os.path.join(REPO_DIR, "SKILL.md")
 GITHUB_TOOLS = os.path.join(SCRIPTS, "github_tools.py")
 RUN_CLAUDE = os.path.join(SCRIPTS, "run_claude.sh")
 
+# Repo-state lookup (stars, gone, has_issues) with github_tools' shared
+# two-tier cache; feeds the tiny-repo audience floor in phase 1.
+from github_tools import _fetch_repo_state as _repo_state
+
 # Interpreter every child subprocess must run under. A bare PYTHON resolved
 # to the user's system python, which lacks the pipeline deps that live only in
 # the owned uv runtime — the same fresh-box failure class that broke the Twitter
@@ -187,6 +191,49 @@ MAINTAINER_ASSOCIATIONS = {"OWNER", "MEMBER", "COLLABORATOR"}
 # help here." 0/1 = off-domain. Tunable.
 MIN_RELEVANCE = 2
 
+# Zero-audience gate (2026-07-17). Root cause of the vestlang #554 spam
+# minimization (post #46421): the issue was the repo owner's self-authored work
+# ticket with zero other commenters, so our comment's only audience was the
+# owner, who hid it as spam within the hour. Require at least one non-bot
+# commenter besides the issue author before we engage, and skip tiny-audience
+# repos (fewer than STAR_FLOOR stars) unless a real multi-person discussion
+# (2+ outside participants) is underway.
+MIN_OUTSIDE_PARTICIPANTS = 1
+STAR_FLOOR = 5
+
+# Bot detection for `gh issue view` comment authors. GraphQL strips the
+# "[bot]" suffix REST shows (github-actions[bot] arrives as plain
+# "github-actions"), so we combine a known-login set with suffix heuristics.
+# A missed bot only weakens the participant/momentum signal marginally.
+KNOWN_BOT_LOGINS = {
+    "github-actions", "dependabot", "dependabot-preview", "renovate",
+    "renovate-bot", "codecov", "codecov-commenter", "vercel", "netlify",
+    "stale", "snyk-bot", "greenkeeper", "coderabbitai", "copilot",
+    "sonarcloud", "cypress", "changeset-bot", "allcontributors",
+    "google-cla", "cla-assistant", "codesandbox-ci", "circleci",
+}
+
+
+def _is_bot_login(login):
+    l = (login or "").lower()
+    return bool(l) and (
+        l in KNOWN_BOT_LOGINS or l.endswith("[bot]") or l.endswith("-bot")
+        or l.endswith("bot]")
+    )
+
+
+def _our_github_handle(_memo={}):
+    """Our own posting handle, lowercased ('' if unresolvable). Excluded from
+    outside_participants so a thread we already commented in doesn't count us
+    as its audience."""
+    if "h" not in _memo:
+        try:
+            from account_resolver import resolve as _resolve
+            _memo["h"] = (_resolve("github") or "").lower()
+        except Exception:
+            _memo["h"] = ""
+    return _memo["h"]
+
 
 def log(msg):
     print(f"[{datetime.now().strftime('%H:%M:%S')}] [post_github] {msg}", flush=True)
@@ -320,13 +367,21 @@ def gh_search(query, limit=SEARCH_PER_TOPIC):
 
 def gh_view_counts(repo, number):
     """Return dict{comment_count, reaction_count, title, body, author, url,
-    maintainer_last_speaker, last_commenter, last_comment_assoc} or None if the
-    issue is no longer open / unfetchable.
+    maintainer_last_speaker, last_commenter, last_comment_assoc,
+    outside_participants, author_is_owner} or None if the issue is no longer
+    open / unfetchable.
 
     `gh issue view --json comments` returns each comment with `authorAssociation`
     (OWNER/MEMBER/COLLABORATOR/CONTRIBUTOR/NONE/...) and `createdAt`. We use the
     most recent comment to detect "maintainer just spoke" so phase 1 can drop
-    those candidates without an extra API call."""
+    those candidates without an extra API call.
+
+    Bot comments (github-actions, dependabot, etc.) are excluded from
+    comment_count (so CI chatter can't inflate delta_score momentum), from the
+    maintainer-last-speaker check (a bot posting after a maintainer shouldn't
+    shadow the maintainer's word), and from outside_participants (the count of
+    distinct non-bot commenters other than the issue author, which feeds the
+    zero-audience gate)."""
     try:
         out = subprocess.check_output(
             ["gh", "issue", "view", str(number), "-R", repo,
@@ -345,18 +400,30 @@ def gh_view_counts(repo, number):
             (g.get("users") or {}).get("totalCount", 0) or g.get("totalCount", 0) or 0
         )
 
-    # Maintainer-just-spoke gate. Sort comments by createdAt desc, look at the
-    # most recent one (regardless of timing). If the issue's last word came from
-    # someone with push access, the thread is being driven and we shouldn't pile
-    # on. The OP's authorAssociation is checked separately (issue.author isn't
-    # included in `comments`, only in the top-level `author` field).
+    issue_author = ((data.get("author") or {}).get("login", "") or "").lower()
+    repo_owner = (repo.split("/", 1)[0] or "").lower()
+    human_comments = [
+        c for c in comments
+        if not _is_bot_login(((c.get("author") or {}).get("login", "")))
+    ]
+    outside_participants = {
+        ((c.get("author") or {}).get("login", "") or "").lower()
+        for c in human_comments
+    } - {issue_author, _our_github_handle(), ""}
+
+    # Maintainer-just-spoke gate. Sort non-bot comments by createdAt desc, look
+    # at the most recent one (regardless of timing). If the issue's last human
+    # word came from someone with push access, the thread is being driven and we
+    # shouldn't pile on. The OP's authorAssociation is checked separately
+    # (issue.author isn't included in `comments`, only in the top-level `author`
+    # field).
     maintainer_last_speaker = False
     last_commenter = ""
     last_comment_assoc = ""
-    if comments:
+    if human_comments:
         try:
             sorted_c = sorted(
-                comments,
+                human_comments,
                 key=lambda c: c.get("createdAt", "") or "",
                 reverse=True,
             )
@@ -369,7 +436,7 @@ def gh_view_counts(repo, number):
             pass
 
     return {
-        "comment_count": len(comments),
+        "comment_count": len(human_comments),
         "reaction_count": reaction_count,
         "title": data.get("title", ""),
         "body": (data.get("body") or ""),
@@ -378,6 +445,8 @@ def gh_view_counts(repo, number):
         "maintainer_last_speaker": maintainer_last_speaker,
         "last_commenter": last_commenter,
         "last_comment_assoc": last_comment_assoc,
+        "outside_participants": len(outside_participants),
+        "author_is_owner": bool(issue_author) and issue_author == repo_owner,
     }
 
 
@@ -437,6 +506,12 @@ def build_prompt(project, config, candidates, cap, top_report, recent_comments,
                 f"last_commenter: {c['last_commenter']} "
                 f"({c.get('last_comment_assoc') or 'NONE'})\n"
             )
+        audience_line = (
+            f"outside_participants: {c.get('outside_participants', '?')}"
+        )
+        if c.get("author_is_owner"):
+            audience_line += " | author_is_owner: true"
+        audience_line += "\n"
         history_block = ""
         try:
             _hb = _render_author_history(
@@ -452,6 +527,7 @@ def build_prompt(project, config, candidates, cap, top_report, recent_comments,
             f"rx {c['reaction_count_t0']}->{c['reaction_count_t1']}) ---\n"
             f"{seed_line}"
             f"{last_speaker_line}"
+            f"{audience_line}"
             f"title: {c['title']}\n"
             f"author: {c['author']}\n"
             f"url: {c['url']}\n"
@@ -590,6 +666,19 @@ takes that ignored what the maintainer just said. Skip when:
     grouped with them by the maintainer.
   - You'd cite a precedent you can't actually link to (Apple ?ppid, Stripe X,
     Shopify Y, etc.). Hand-wavy precedent name-drops read as fake-expert.
+  - The point you'd make is already stated in the issue body or an existing
+    comment. Re-deriving the author's own caveats in your voice reads as an
+    LLM paraphrasing them back at themselves; that exact pattern got our
+    vestlang comment hidden as spam within the hour. If you can't add
+    something the thread doesn't already contain, skip.
+  - `author_is_owner: true` and the issue reads like the owner's internal
+    work ticket (committed scope, acceptance criteria, "design decision to
+    settle", self-addressed spec). The owner's notification inbox is the
+    only audience, and they didn't ask for outside input.
+  - `outside_participants` is 1 and your comment doesn't offer that one
+    other person something genuinely new. Thin threads reach you already
+    filtered (zero-participant threads are dropped upstream), but 1 is
+    still thin; treat it as a high bar, not a green light.
 
 ## YOUR JOB
 
@@ -872,6 +961,8 @@ def main():
 
     candidates = []
     skipped_maintainer = 0
+    skipped_no_audience = 0
+    skipped_small_repo = 0
     for item in raw[:CLAUDE_CANDIDATE_LIMIT * 3]:
         repo, number = parse_repo_number(item.get("url"))
         if not repo:
@@ -890,6 +981,34 @@ def main():
                 f"{counts.get('last_comment_assoc')})"
             )
             continue
+        # Zero-audience gate. Nobody but the issue author (and bots) has ever
+        # touched this thread, so a comment's only reader is the author's
+        # notification inbox. Worst case is the author being the repo owner
+        # writing their own work ticket (vestlang #554, post #46421): the one
+        # person notified is the one person who can hide us as spam.
+        if counts.get("outside_participants", 0) < MIN_OUTSIDE_PARTICIPANTS:
+            skipped_no_audience += 1
+            log(
+                f"  skip {repo}#{number}: no outside participants "
+                f"(author={counts.get('author')}, "
+                f"owner_authored={counts.get('author_is_owner')})"
+            )
+            continue
+        # Tiny-repo audience floor. A repo with almost no stars has no
+        # bystander audience reading its issues; require a real multi-person
+        # discussion before engaging there. stars=None (fetch failed) passes:
+        # fail open, the participant gate above already ran.
+        _owner, _name = repo.split("/", 1)
+        _stars = _repo_state(_owner, _name).get("stars")
+        if (_stars is not None and _stars < STAR_FLOOR
+                and counts.get("outside_participants", 0) < 2):
+            skipped_small_repo += 1
+            log(
+                f"  skip {repo}#{number}: {_stars} stars < {STAR_FLOOR} "
+                f"and thin discussion "
+                f"({counts.get('outside_participants')} outside participants)"
+            )
+            continue
         candidates.append({
             "repo": repo,
             "number": number,
@@ -899,11 +1018,15 @@ def main():
             "author": counts["author"],
             "comment_count_t0": counts["comment_count"],
             "reaction_count_t0": counts["reaction_count"],
+            "outside_participants": counts.get("outside_participants", 0),
+            "author_is_owner": bool(counts.get("author_is_owner")),
             "search_topic": item.get("search_topic"),
         })
     log(
         f"Phase 1: {len(candidates)} candidates with T0 snapshot "
-        f"(skipped {skipped_maintainer} for maintainer-just-spoke)"
+        f"(skipped {skipped_maintainer} maintainer-just-spoke, "
+        f"{skipped_no_audience} no-outside-participants, "
+        f"{skipped_small_repo} tiny-repo)"
     )
     if not candidates:
         log("No live open issues to re-poll. Exiting.")
@@ -937,6 +1060,10 @@ def main():
             continue
         c["comment_count_t1"] = counts["comment_count"]
         c["reaction_count_t1"] = counts["reaction_count"]
+        # Participants only grow, so no re-skip needed; refresh so the prompt
+        # shows the T1 value.
+        c["outside_participants"] = counts.get(
+            "outside_participants", c.get("outside_participants", 0))
         c["delta_score"] = delta_score(
             c["comment_count_t0"], c["reaction_count_t0"],
             c["comment_count_t1"], c["reaction_count_t1"],

package/scripts/s4l_ctl.sh

@@ -63,13 +63,13 @@ PYEOF
     if [ "$YES" != "1" ]; then
       echo "REFUSING: 'approve $*' will POST those cards to live X. Re-run with --yes to confirm." >&2; exit 3; fi
     echo "posting cards [$nums] ..."
-    tool post_drafts 900 "{\"batch_id\":\"$BATCH\",\"post\":[$nums]}" ; echo ;;
+    tool approve_drafts 900 "{\"batch_id\":\"$BATCH\",\"post\":[$nums]}" ; echo ;;
   approve-all)
     n="$(pending_count)"
     if [ "$YES" != "1" ]; then
       echo "REFUSING: approve-all will POST all $n pending cards to live X. Re-run with --yes to confirm." >&2; exit 3; fi
     echo "posting all $n pending cards ..."
-    tool post_drafts 1800 "{\"batch_id\":\"$BATCH\",\"post_all\":true}" ; echo ;;
+    tool approve_drafts 1800 "{\"batch_id\":\"$BATCH\",\"post_all\":true}" ; echo ;;
   *)
     echo "usage: s4l_ctl.sh {status|count|drafts|approve <n...>|approve-all} [--yes]" >&2; exit 64 ;;
 esac

package/scripts/s4l_posting_mode.py

@@ -76,8 +76,10 @@ def main() -> int:
     try:
         if cmd == "get":
             try:
+                # http_api raises SystemExit (not Exception) on terminal
+                # failure, so both must be caught here and below.
                 r = api_get("/api/v1/installations/posting-mode")
-            except Exception as e:
+            except (Exception, SystemExit) as e:
                 # Offline / server unreachable: answer from the last-known
                 # cache so UIs keep showing the user's chosen mode instead of
                 # silently falling back to "Steady". No "error" key: consumers
@@ -109,7 +111,7 @@ def main() -> int:
             return 0
         print(json.dumps({"error": f"unknown command {cmd!r}"}))
         return 2
-    except Exception as e:  # network / API failure: JSON error, non-zero exit
+    except (Exception, SystemExit) as e:  # network / API failure: JSON error, non-zero exit
         print(json.dumps({"error": str(e)}))
         return 1
 

package/scripts/strike_alert.py

@@ -700,6 +700,10 @@ def _next_steps(platform):
             "   pattern. Watch the 'moderated here in last 90 days' count: a\n"
             "   rising count on a not-yet-banned sub is an early bad-fit signal.\n"
         )
+    try:
+        from github_tools import DYNAMIC_BLOCK_THRESHOLD as _thr
+    except Exception:
+        _thr = "N"
     return (
         "--- Next steps ---\n"
         "1. Inspect the thread to see if the comment was deleted, hidden,\n"
@@ -708,7 +712,7 @@ def _next_steps(platform):
         "   config.json -> exclusions.github_repos. Owner-level entries\n"
         "   match all repos under that owner.\n"
         "3. The auto-blocklist (github_tools._dynamic_owner_blocklist)\n"
-        "   already covers any owner with >=2 strikes in 90 days.\n"
+        f"   already covers any owner with >={_thr} real strikes in 90 days.\n"
     )
 
 

package/scripts/test_percard_posting.py

@@ -37,14 +37,14 @@ sentry_init.init_sentry = lambda *a, **k: None
 sentry_init.capture = lambda *a, **k: None
 sys.modules["sentry_init"] = sentry_init
 
-# Track concurrency + record every post_drafts call.
+# Track concurrency + record every approve_drafts call.
 overlap_detected = []
 inflight = {"n": 0}
 inflight_lock = threading.Lock()
 calls = []
 activity_events = []
 
-def fake_post_drafts(batch_id, post=None, edits=None, timeout=900, activity_label=None):
+def fake_approve_drafts(batch_id, post=None, edits=None, timeout=900, activity_label=None):
     with inflight_lock:
         inflight["n"] += 1
         if inflight["n"] > 1:
@@ -65,7 +65,7 @@ def fake_post_drafts(batch_id, post=None, edits=None, timeout=900, activity_labe
     return {"posted": n_posted}
 
 st = types.ModuleType("s4l_state")
-st.post_drafts = fake_post_drafts
+st.approve_drafts = fake_approve_drafts
 st.write_activity = lambda state, label: activity_events.append((state, label))
 st.accessibility_trusted = lambda: True
 st.clear_review_request = lambda: None