@m13v/s4l 1.7.6-rc.13 → 1.7.6-rc.15

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.6-rc.13",
-  "installedAt": "2026-07-17T20:44:58.166Z"
+  "version": "1.7.6-rc.15",
+  "installedAt": "2026-07-17T21:35:54.890Z"
 }

package/mcp/manifest.json

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

@@ -331,7 +331,7 @@ def _truncate(s, n=320):
     return s if len(s) <= n else s[: n - 1] + "…"
 
 
-def _set_thread_text(thread_tv, text, link_url, *, font_size=12):
+def _set_thread_text(thread_tv, text, link_url, *, font_size=12, title=None):
     """Set the thread-quote text on `thread_tv`: the FULL text, never
     trimmed (2026-07-16 user direction -- the box scrolls instead when it
     doesn't fit; see its NSScrollView wrapper in _render()). A leading
@@ -340,8 +340,15 @@ def _set_thread_text(thread_tv, text, link_url, *, font_size=12):
     of how long the thread is or where the box happens to be scrolled to
     (the old trailing-link placement could end up scrolled out of view, or
     -- before scrolling existed at all -- get silently truncated off the
-    end; see the superseded _fit_thread_body this replaced)."""
+    end; see the superseded _fit_thread_body this replaced).
+
+    `title` (2026-07-17 user direction, Reddit): when given, it's drawn BOLD
+    on its own line ahead of `text`, so a Reddit card shows the post title in
+    bold with the selftext body beneath it in the same quote box. Twitter and
+    title-only Reddit threads pass title=None and render `text` alone,
+    exactly as before."""
     text = (text or "").strip()
+    title = (title or "").strip()
     body = NSMutableAttributedString.alloc().initWithString_attributes_("", {})
     if link_url:
         body.appendAttributedString_(
@@ -356,6 +363,19 @@ def _set_thread_text(thread_tv, text, link_url, *, font_size=12):
                 },
             )
         )
+    if title:
+        # Bold title on its own line; a trailing newline separates it from the
+        # body only when there IS a body (a title with no selftext shouldn't
+        # leave a dangling blank line).
+        body.appendAttributedString_(
+            NSAttributedString.alloc().initWithString_attributes_(
+                title + ("\n" if text else ""),
+                {
+                    NSFontAttributeName: NSFont.boldSystemFontOfSize_(font_size),
+                    NSForegroundColorAttributeName: NSColor.labelColor(),
+                },
+            )
+        )
     body.appendAttributedString_(
         NSAttributedString.alloc().initWithString_attributes_(
             text,
@@ -1598,7 +1618,19 @@ class _ReviewController(NSObject):
             pass
         if thread_url:
             thread_tv.setDelegate_(self)
-        _set_thread_text(thread_tv, thread_en or d.get("thread_text"), thread_url)
+        # Reddit (2026-07-17 user direction): the thread has a TITLE and a
+        # BODY (selftext). Render the title bold with the body beneath it in
+        # this same quote box. thread_text carries the title (see
+        # merge_review_queue._reddit_plan_to_candidates); thread_selftext is
+        # the body, empty for link posts / title-only threads (then this falls
+        # through to the plain title-only render). Twitter has no selftext, so
+        # it always takes the else branch and renders exactly as before.
+        _thread_title = thread_en or d.get("thread_text")
+        _thread_body = (d.get("thread_selftext") or "").strip() if _plat == "reddit" else ""
+        if _thread_body:
+            _set_thread_text(thread_tv, _thread_body, thread_url, title=_thread_title)
+        else:
+            _set_thread_text(thread_tv, _thread_title, thread_url)
         thread_scroll.setDocumentView_(thread_tv)
         content.addSubview_(thread_scroll)
         # Reply heading — bold. A concise "project/lane · viral N" tag rides

package/mcp/package.json

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

@@ -229,7 +229,14 @@ def _recent_batches_not_progressing(min_batches: int = BATCH_PROGRESSION_MIN_BAT
         import http_api  # noqa: E402
 
         resp = http_api.api_get("/api/v1/twitter-batches", {"list": "1", "limit": str(min_batches)})
-        batches = (resp or {}).get("batches") or []
+        # http_api.api_get returns the RAW envelope {"ok":..,"data":{"batches":[..],
+        # "owner_host":..}} — it does NOT unwrap "data". The batches live at
+        # resp["data"]["batches"], never at resp["batches"]. Reading the wrong key
+        # made this return [] -> len<min -> False on EVERY call, so batches_stuck was
+        # hardwired False and the "drafting is not actually happening" stall cause
+        # could never be selected (missed Nhat's 07-15 phase2b-prep pileup entirely).
+        # Do NOT collapse back to resp.get("batches").
+        batches = ((resp or {}).get("data") or {}).get("batches") or []
         if len(batches) < min_batches:
             return False  # not enough history yet to conclude a stall
         return all((b or {}).get("current_phase") not in BATCH_PROGRESSED_PHASES for b in batches)

package/scripts/merge_review_queue.py

@@ -168,6 +168,14 @@ def _reddit_plan_to_candidates(plan: dict) -> list:
             "thread_url": d.get("thread_url"),
             "thread_author": d.get("thread_author"),
             "thread_text": d.get("thread_title") or "",
+            # Reddit threads carry a title (thread_text, above) AND a body
+            # (selftext). Both matter to a reviewer: the title alone often
+            # can't be judged without the post body it heads. The card renders
+            # the title bold and the selftext beneath it in the same quote box
+            # (2026-07-17 user direction). Link posts / title-only threads have
+            # an empty selftext, so the card falls back to title-only. Decisions
+            # carry it as `selftext` (from the candidate) or `thread_selftext`.
+            "thread_selftext": d.get("selftext") or d.get("thread_selftext") or "",
             "matched_project": plan.get("project_name"),
             "reply_text": d.get("text"),
             "engagement_style": d.get("engagement_style"),

package/scripts/platform_strike_events.py

@@ -106,12 +106,20 @@ def _venue(post: dict) -> str | None:
     return None
 
 
-def _removed_event(post: dict) -> dict:
+def _removed_event(post: dict, venue_count: int = 0) -> dict:
     venue = _venue(post)
     is_own_thread = bool(post.get("thread_url")) and post.get("thread_url") == post.get("our_url")
     kind = "top-level post" if is_own_thread else "comment/reply"
     posted = str(post.get("posted_at") or "")[:10]
     detected = str(post.get("status_checked_at") or "")[:10]
+    # venue_count = how many of our posts were removed in this same venue inside
+    # the sweep window. Surfaces clustering (one venue removing many of our
+    # posts is a venue-fit lesson, not N unrelated content lessons) directly in
+    # the note the digest reads.
+    cluster = ""
+    if venue and venue_count > 1:
+        cluster = (f" This is 1 of {venue_count} of our posts removed in"
+                   f" {venue} in the recent window (a venue-level pattern).")
     note = (
         f"Platform moderation strike: our {post.get('platform')} {kind}"
         f"{' in ' + venue if venue else ''} is now status='{post.get('status')}'"
@@ -120,6 +128,7 @@ def _removed_event(post: dict) -> dict:
         f" account {post.get('our_account')}."
         f" Machine-derived signal, not a human card decision: a moderator or"
         f" platform filter judged this content unwelcome in that venue."
+        f"{cluster}"
     )
     return {
         "event_uuid": str(uuid.uuid5(EVENT_NS, f"platform_removed:post:{post['id']}")),
@@ -156,7 +165,7 @@ def _ban_event(entry: dict) -> dict:
     }
 
 
-def collect_events(window_days: int) -> tuple[list[dict], int, int]:
+def collect_events(window_days: int, dry_run: bool = False) -> tuple[list[dict], int, int]:
     """Returns (events, removed_count, ban_count)."""
     cfg = _load_config()
     local_projects = {p.get("name") for p in (cfg.get("projects") or []) if p.get("name")}
@@ -170,7 +179,7 @@ def collect_events(window_days: int) -> tuple[list[dict], int, int]:
     })
     posts = ((resp or {}).get("data") or {}).get("posts") or []
 
-    removed_events = []
+    fresh = []
     for p in posts:
         if p.get("project_name") not in local_projects:
             continue
@@ -179,7 +188,47 @@ def collect_events(window_days: int) -> tuple[list[dict], int, int]:
         detected = _parse_ts(p.get("status_checked_at"))
         if detected is None or detected < cutoff:
             continue
-        removed_events.append(_removed_event(p))
+        fresh.append(p)
+
+    # Per-venue removal counts (clustering signal surfaced in each event note).
+    venue_counts: dict[str, int] = {}
+    for p in fresh:
+        v = _venue(p)
+        if v:
+            venue_counts[v] = venue_counts.get(v, 0) + 1
+    removed_events = [_removed_event(p, venue_counts.get(_venue(p) or "", 0))
+                      for p in fresh]
+
+    # Deterministic community-ban detection (2026-07-17): before reading the
+    # ban denylist, inspect the logged-in ban state of every reddit subreddit
+    # that struck us this window and persist newly-confirmed bans (reason
+    # 'account_blocked_in_sub'). This is what turns a pile of per-post removals
+    # into a single platform_banned learning signal, and upgrades weak manual
+    # denylist entries so their ban event can finally fire. Read-only browser
+    # attach; no-ops gracefully (returns unknown) on installs without a live
+    # Reddit session, and can be disabled with S4L_STRIKE_BAN_CHECK=0.
+    if os.environ.get("S4L_STRIKE_BAN_CHECK", "1") not in ("0", "false", "no"):
+        reddit_subs = sorted({
+            re.search(r"reddit\.com/r/([^/]+)/", (p.get("thread_url") or p.get("our_url") or "")).group(1)
+            for p in fresh
+            if re.search(r"reddit\.com/r/([^/]+)/", (p.get("thread_url") or p.get("our_url") or ""))
+        })
+        if reddit_subs:
+            try:
+                import reddit_ban_check
+                if dry_run:
+                    # read-only: detect and report, never persist
+                    st = reddit_ban_check.banned_state(reddit_subs)
+                    banned = [s for s, v in st.items() if v is True]
+                    log(f"ban_check (dry run) subs={len(reddit_subs)} banned={banned}")
+                else:
+                    res = reddit_ban_check.record_confirmed_bans(reddit_subs)
+                    log(f"ban_check subs={len(reddit_subs)} banned={len(res.get('banned') or [])}"
+                        f" recorded={res.get('recorded')} upgraded={res.get('upgraded')}")
+                    if res.get("recorded") or res.get("upgraded"):
+                        cfg = _load_config()  # reload so new ban entries below are seen
+            except Exception as e:
+                log(f"ban_check_error (non-fatal): {e}")
 
     ban_events = []
     for entry in ((cfg.get("subreddit_bans") or {}).get("comment_blocked") or []):
@@ -194,7 +243,7 @@ def collect_events(window_days: int) -> tuple[list[dict], int, int]:
 
 
 def sweep(window_days: int = 14, dry_run: bool = False) -> dict:
-    events, n_removed, n_banned = collect_events(window_days)
+    events, n_removed, n_banned = collect_events(window_days, dry_run=dry_run)
     inserted = 0
     duplicates = 0
     if dry_run:

package/scripts/preview_reddit_card.py

@@ -0,0 +1,38 @@
+# Scratch preview: renders one Reddit review card with a title + selftext,
+# to visually verify the bold-title-over-body thread box (2026-07-17).
+import os, sys
+os.environ["S4L_STATE_DIR"] = "/tmp/s4l-card-preview-state"
+os.makedirs("/tmp/s4l-card-preview-state", exist_ok=True)
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "mcp", "menubar"))
+from AppKit import NSApplication
+import s4l_card
+
+drafts = [{
+    "n": 1,
+    "platform": "reddit",
+    "thread_author": "SureThing07",
+    "thread_text": "Im fu**ed. I've realised the whole game is a placeholder",
+    "thread_selftext": (
+        "I've been building this solo for eight months and I just opened the "
+        "codebase after a week off. Half of it is stubs I meant to come back "
+        "to. The save system? Placeholder. The combat? Placeholder wired to a "
+        "real animation so it LOOKED done. I genuinely can't tell how much of "
+        "this game actually exists anymore. How do you all deal with this?"
+    ),
+    "reply_text": (
+        "my rule of thumb from solo projects: by month six, maybe a third of "
+        "the code is actually load-bearing and the rest is scaffolding you "
+        "forgot you wrote."
+    ),
+    "thread_url": "https://www.reddit.com/r/gamedev/comments/abc123/placeholder/",
+    "candidate_id": "rd-preview1",
+    "project": "podlog",
+    "engagement_style": "empathize",
+    "search_topic": "solo dev burnout",
+    "stats": {"replies": 34, "author_followers": 0,
+              "tweet_posted_at": "2026-07-17T14:00:00Z"},
+}]
+app = NSApplication.sharedApplication()
+s4l_card.present_review(drafts, on_decision=lambda d: None,
+                        on_complete=lambda ds: app.terminate_(None))
+app.run()

package/scripts/reddit_ban_check.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""Deterministic Reddit community-ban detection.
+
+When a post is discovered removed, "was that one post moderated, or is our
+account BANNED from the whole community?" is not answerable from the removal
+object itself: a mod-removed comment scrubs to author=[deleted]/body=[removed]
+with no reason, and a ban does NOT retroactively delete our older comments, so
+"our comments are still visible there" is NOT evidence we are un-banned.
+
+The authoritative signal is the logged-in view of `/r/<sub>/about.json`, whose
+`user_is_banned` field is populated per the requesting account's session. We
+already hold a logged-in Reddit browser (the reddit-agent / reddit-harness
+Chrome); this module CDP-attaches to it read-only (one navigation, N same-origin
+fetches, no clicks/posts) and reads that field. Mirrors the read-only carve-out
+pattern used elsewhere (linkedin_browser sidebar pre-check).
+
+Graceful degradation: if no Reddit session is reachable (customer install with
+no browser, wrong account, session logged out), every checker returns None and
+callers MUST treat None as "unknown, do nothing" — never as "not banned".
+
+Usage:
+    python3 scripts/reddit_ban_check.py ClaudeAI theravada rust      # ad-hoc
+    python3 scripts/reddit_ban_check.py --record --project podlog r/X # detect+persist
+
+Public API:
+    banned_state(subs)        -> {sub_lower: True|False|None}
+    is_banned(sub)            -> True|False|None
+    record_confirmed_bans(subs, project=None)
+        -> {"banned": [...], "recorded": [...], "upgraded": [...], "unknown": [...]}
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# about.json JS: fetch each sub's logged-in metadata, return the ban flags.
+_ABOUT_JS = r"""
+async (subs) => {
+  const out = {};
+  for (const s of subs) {
+    try {
+      const r = await fetch(`https://old.reddit.com/r/${s}/about.json`,
+                            {headers:{'Accept':'application/json'}, credentials:'include'});
+      if (!r.ok) { out[s] = {http: r.status}; continue; }
+      const d = (await r.json()).data || {};
+      out[s] = { banned: d.user_is_banned === true,
+                 muted: d.user_is_muted === true,
+                 has_flag: ('user_is_banned' in d) };
+    } catch (e) { out[s] = {err: String(e).slice(0,80)}; }
+    await new Promise(x => setTimeout(x, 250));
+  }
+  return out;
+}
+"""
+
+
+def _norm(sub: str) -> str:
+    s = (sub or "").strip()
+    m = re.search(r"/r/([^/]+)", s)
+    if m:
+        s = m.group(1)
+    return s.strip().strip("/").lower()
+
+
+def _reddit_page(pw):
+    """Attach to the running logged-in Reddit Chrome and return (browser, page).
+
+    Prefers REDDIT_CDP_URL, else discovers the reddit-agent port via
+    reddit_browser.find_reddit_cdp_port. Opens a DEDICATED page so we never
+    fight the live harness tab. Returns (None, None) if unreachable."""
+    import urllib.request
+
+    ws = None
+    cdp_url = (os.environ.get("REDDIT_CDP_URL") or "").strip()
+    if cdp_url:
+        ws = cdp_url
+    else:
+        try:
+            from reddit_browser import find_reddit_cdp_port
+            port = find_reddit_cdp_port()
+            if not port:
+                return None, None
+            with urllib.request.urlopen(
+                f"http://127.0.0.1:{port}/json/version", timeout=3
+            ) as r:
+                ws = json.load(r)["webSocketDebuggerUrl"]
+        except Exception:
+            return None, None
+    try:
+        browser = pw.chromium.connect_over_cdp(ws)
+        ctx = browser.contexts[0] if browser.contexts else browser.new_context()
+        page = ctx.new_page()
+        page.set_default_timeout(20000)
+        return browser, page
+    except Exception:
+        return None, None
+
+
+def banned_state(subs) -> dict:
+    """Return {sub_lower: True|False|None} for each sub. None = unknown
+    (no session / fetch failed): callers MUST NOT treat None as un-banned."""
+    norm = []
+    for s in subs:
+        n = _norm(s)
+        if n and n not in norm:
+            norm.append(n)
+    result = {n: None for n in norm}
+    if not norm:
+        return result
+    try:
+        from playwright.sync_api import sync_playwright
+    except Exception:
+        return result
+    with sync_playwright() as pw:
+        browser, page = _reddit_page(pw)
+        if page is None:
+            return result
+        try:
+            page.goto("https://old.reddit.com/", wait_until="domcontentloaded",
+                      timeout=20000)
+            # confirm we actually have a logged-in session; a logged-out view
+            # reports user_is_banned=false for everything, a false negative.
+            me = page.evaluate(
+                "async () => { try { const r = await fetch("
+                "'https://old.reddit.com/api/me.json', {credentials:'include'}); "
+                "const d = await r.json(); return (d.data && d.data.name) || null; } "
+                "catch(e){ return null; } }"
+            )
+            if not me:
+                return result  # not logged in -> all unknown
+            raw = page.evaluate(_ABOUT_JS, norm)
+        except Exception:
+            return result
+        finally:
+            try:
+                page.close()
+            except Exception:
+                pass
+    for n in norm:
+        v = (raw or {}).get(n) or {}
+        if v.get("has_flag"):
+            result[n] = bool(v.get("banned"))
+        else:
+            result[n] = None  # http error / missing field -> unknown
+    return result
+
+
+def is_banned(sub) -> "bool|None":
+    return banned_state([sub]).get(_norm(sub))
+
+
+def record_confirmed_bans(subs, project=None) -> dict:
+    """Check each sub and persist newly-confirmed community bans into
+    config.json subreddit_bans.comment_blocked with reason
+    'account_blocked_in_sub' (the reason platform_strike_events reads to emit
+    platform_banned learning events). Upgrades pre-existing weak entries
+    (reason=None) to the confirmed reason. Never records on None (unknown)."""
+    from config import config_path
+    from post_reddit import _make_ban_entry, _ban_entry_sub
+
+    state = banned_state(subs)
+    banned = [s for s, v in state.items() if v is True]
+    unknown = [s for s, v in state.items() if v is None]
+    recorded, upgraded = [], []
+    if not banned:
+        return {"banned": [], "recorded": [], "upgraded": [], "unknown": unknown}
+
+    path = config_path()
+    with open(path) as f:
+        cfg = json.load(f)
+    bans = cfg.setdefault("subreddit_bans", {})
+    blocked = bans.setdefault("comment_blocked", [])
+    by_sub = {(_ban_entry_sub(e) or "").lower(): e for e in blocked}
+
+    for sub in banned:
+        entry = by_sub.get(sub)
+        if entry is None:
+            blocked.append(_make_ban_entry(sub, "account_blocked_in_sub", project))
+            recorded.append(sub)
+        elif entry.get("reason") != "account_blocked_in_sub":
+            # upgrade a weak/manual entry so the digest ban event can fire
+            from datetime import datetime, timezone
+            entry["reason"] = "account_blocked_in_sub"
+            if not entry.get("added_at"):
+                entry["added_at"] = datetime.now(timezone.utc).strftime(
+                    "%Y-%m-%dT%H:%M:%SZ")
+            entry.setdefault("noticed_by_project", project)
+            upgraded.append(sub)
+
+    if recorded or upgraded:
+        blocked.sort(key=lambda e: (_ban_entry_sub(e) or ""))
+        with open(path, "w") as f:
+            json.dump(cfg, f, indent=2)
+            f.write("\n")
+    return {"banned": banned, "recorded": recorded, "upgraded": upgraded,
+            "unknown": unknown}
+
+
+def main() -> int:
+    import argparse
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("subs", nargs="+", help="subreddit names or /r/x URLs")
+    ap.add_argument("--record", action="store_true",
+                    help="persist confirmed bans to config.json")
+    ap.add_argument("--project", default=None, help="audit breadcrumb")
+    args = ap.parse_args()
+    if args.record:
+        print(json.dumps(record_confirmed_bans(args.subs, args.project), indent=2))
+    else:
+        print(json.dumps(banned_state(args.subs), indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/release-mcpb.sh

@@ -384,6 +384,28 @@ NODE_RUNTIME_PLATFORM="darwin-arm64"
 NODE_VENDOR_DIR="$MCP_DIR/vendor/node-$NODE_RUNTIME_PLATFORM"
 NODE_VENDOR_BIN="$NODE_VENDOR_DIR/bin/node"
 NODE_CACHE_DIR="$REPO_ROOT/.cache/node-runtime"
+# Can THIS build host execute the vendored target binary? The .mcpb always
+# vendors darwin-arm64 (that is where it runs), but the release itself is cut
+# from CI on linux-x64. Executing a darwin-arm64 node on a linux-x64 runner is
+# an `Exec format error` (exit 126) -- what broke every rc from 1.7.6-rc.11 on.
+# Run the exec-based `--version` sanity checks ONLY when the host os/arch matches
+# the vendored target; otherwise verify by presence + executable bit, which is
+# all a cross-build can honestly assert.
+case "$(uname -s)" in
+  Darwin) HOST_OS="darwin" ;;
+  Linux)  HOST_OS="linux" ;;
+  *)      HOST_OS="unknown" ;;
+esac
+case "$(uname -m)" in
+  arm64|aarch64) HOST_ARCH="arm64" ;;
+  x86_64|amd64)  HOST_ARCH="x64" ;;
+  *)             HOST_ARCH="unknown" ;;
+esac
+if [[ "$HOST_OS-$HOST_ARCH" == "$NODE_RUNTIME_PLATFORM" ]]; then
+  HOST_CAN_EXEC_VENDORED_NODE=1
+else
+  HOST_CAN_EXEC_VENDORED_NODE=0
+fi
 say "Vendoring Node $NODE_RUNTIME_VERSION ($NODE_RUNTIME_PLATFORM) for the .mcpb"
 if [[ ! -x "$NODE_VENDOR_BIN" ]]; then
   NODE_TARBALL="node-$NODE_RUNTIME_VERSION-$NODE_RUNTIME_PLATFORM.tar.gz"
@@ -406,9 +428,13 @@ if [[ ! -x "$NODE_VENDOR_BIN" ]]; then
   chmod +x "$NODE_VENDOR_BIN"
 fi
 [[ -x "$NODE_VENDOR_BIN" ]] || die "vendored node binary missing/not executable at $NODE_VENDOR_BIN"
-VENDORED_NODE_VER="$("$NODE_VENDOR_BIN" --version)"
-[[ "$VENDORED_NODE_VER" == "$NODE_RUNTIME_VERSION" ]] || die "vendored node reports $VENDORED_NODE_VER, expected $NODE_RUNTIME_VERSION"
-echo "  vendored node: $VENDORED_NODE_VER at mcp/vendor/node-$NODE_RUNTIME_PLATFORM/bin/node ($(du -h "$NODE_VENDOR_BIN" | cut -f1))"
+if [[ "$HOST_CAN_EXEC_VENDORED_NODE" == "1" ]]; then
+  VENDORED_NODE_VER="$("$NODE_VENDOR_BIN" --version)"
+  [[ "$VENDORED_NODE_VER" == "$NODE_RUNTIME_VERSION" ]] || die "vendored node reports $VENDORED_NODE_VER, expected $NODE_RUNTIME_VERSION"
+  echo "  vendored node: $VENDORED_NODE_VER at mcp/vendor/node-$NODE_RUNTIME_PLATFORM/bin/node ($(du -h "$NODE_VENDOR_BIN" | cut -f1))"
+else
+  echo "  vendored node: present at mcp/vendor/node-$NODE_RUNTIME_PLATFORM/bin/node ($(du -h "$NODE_VENDOR_BIN" | cut -f1)); --version self-check skipped (host $HOST_OS-$HOST_ARCH cannot exec $NODE_RUNTIME_PLATFORM)"
+fi
 
 # ---- 4. Pack the .mcpb ------------------------------------------------------
 say "Packing $BUNDLE"
@@ -474,10 +500,15 @@ VENDOR_CHECK_DIR="$(mktemp -d)"
 unzip -q -o "$BUNDLE" "vendor/node-$NODE_RUNTIME_PLATFORM/bin/node" -d "$VENDOR_CHECK_DIR"
 VENDOR_CHECK_BIN="$VENDOR_CHECK_DIR/vendor/node-$NODE_RUNTIME_PLATFORM/bin/node"
 [[ -x "$VENDOR_CHECK_BIN" ]] || die "vendored node in bundle lost its executable bit"
-VENDOR_CHECK_VER="$("$VENDOR_CHECK_BIN" --version)"
-[[ "$VENDOR_CHECK_VER" == "$NODE_RUNTIME_VERSION" ]] || die "vendored node in bundle reports $VENDOR_CHECK_VER, expected $NODE_RUNTIME_VERSION"
-rm -rf "$VENDOR_CHECK_DIR"
-echo "  vendored node runs from bundle: $VENDOR_CHECK_VER ok"
+if [[ "$HOST_CAN_EXEC_VENDORED_NODE" == "1" ]]; then
+  VENDOR_CHECK_VER="$("$VENDOR_CHECK_BIN" --version)"
+  [[ "$VENDOR_CHECK_VER" == "$NODE_RUNTIME_VERSION" ]] || die "vendored node in bundle reports $VENDOR_CHECK_VER, expected $NODE_RUNTIME_VERSION"
+  rm -rf "$VENDOR_CHECK_DIR"
+  echo "  vendored node runs from bundle: $VENDOR_CHECK_VER ok"
+else
+  rm -rf "$VENDOR_CHECK_DIR"
+  echo "  vendored node survives bundle round-trip with exec bit intact; --version run skipped (host $HOST_OS-$HOST_ARCH cannot exec $NODE_RUNTIME_PLATFORM)"
+fi
 
 if [[ "$DO_RELEASE" == "0" ]]; then
   say "Done (--no-release). Bundle ready at: $BUNDLE"

package/scripts/strike_alert.py

@@ -455,10 +455,93 @@ def _owner_strike_count(owner, days=90):
     return (live_count, raw_count)
 
 
-def _format_subject(post, repo_state=None):
+def _subreddit_from_url(url):
+    if not url:
+        return None
+    m = re.search(r"reddit\.com/r/([^/]+)", url)
+    return m.group(1).lower() if m else None
+
+
+def _subreddit_strike_count(sub, days=90):
+    """How many of our reddit posts in r/<sub> were moderated (removed/deleted)
+    in the last `days` days. The reddit analogue of _owner_strike_count: turns a
+    single strike email into 'this is the Nth removal in this community', which
+    is the clustering signal that separates a chronic bad-fit venue from a
+    one-off removal. Returns 0 on any lookup failure (never blocks the email)."""
+    if not sub:
+        return 0
+    try:
+        resp = api_get("/api/v1/posts/thread-urls", query={
+            "platform": "reddit", "moderated_within_days": int(days),
+        })
+    except Exception:
+        return 0
+    urls = (resp.get("data") or {}).get("thread_urls") or []
+    return sum(1 for u in urls if _subreddit_from_url(u) == sub)
+
+
+def _recorded_ban(sub, config, account):
+    """True if r/<sub> is already on the config.json comment_blocked denylist
+    with reason 'account_blocked_in_sub' for this account (the recorded output
+    of the deterministic ban check). Account-scoped, matching
+    reddit_tools._load_comment_blocked_subs semantics."""
+    if not sub:
+        return False
+    acct = (account or "").lower()
+    for entry in ((config.get("subreddit_bans") or {}).get("comment_blocked") or []):
+        if not isinstance(entry, dict):
+            continue
+        if (entry.get("sub") or "").strip().lower() != sub:
+            continue
+        if entry.get("reason") != "account_blocked_in_sub":
+            continue
+        ent_acct = (entry.get("account") or "").lower()
+        if ent_acct and acct and ent_acct != acct:
+            continue
+        return True
+    return False
+
+
+def _reddit_ban_verdict(subs, config, account):
+    """Return {sub: 'banned'|'not_banned'|'unknown'} for reddit strike subs.
+
+    Prefers a single live deterministic check (reddit_ban_check.banned_state,
+    one browser attach for the whole sweep, read-only) and falls back to the
+    recorded config denylist when no session is reachable or the check is
+    disabled via S4L_STRIKE_BAN_CHECK=0. A recorded ban is authoritative even
+    when the live check says unknown (session down) so we never downgrade a
+    known ban to 'single-post removal'."""
+    verdict = {}
+    live = {}
+    if subs and os.environ.get("S4L_STRIKE_BAN_CHECK", "1") not in ("0", "false", "no"):
+        try:
+            import reddit_ban_check
+            live = reddit_ban_check.banned_state(list(subs)) or {}
+        except Exception as e:
+            print(f"[strike_alert] reddit_ban_check unavailable (non-fatal): {e}",
+                  file=sys.stderr)
+    for sub in subs:
+        lv = live.get(sub)
+        if lv is True:
+            verdict[sub] = "banned"
+        elif _recorded_ban(sub, config, account):
+            verdict[sub] = "banned"
+        elif lv is False:
+            verdict[sub] = "not_banned"
+        else:
+            verdict[sub] = "unknown"
+    return verdict
+
+
+def _format_subject(post, repo_state=None, sub_ban=None):
     platform = post["platform"] or "?"
     status = post["status"] or "?"
     tag = "STRIKE"
+    if platform == "reddit" and sub_ban == "banned":
+        # Account is banned from the whole community, not just this post
+        # removed. Loud subject tag so a ban is visually distinct from the
+        # far more common single-post removal.
+        tag = "STRIKE-BANNED"
     if platform == "github" and repo_state == "repo_gone":
         # Owner nuked the whole repo. Not a moderation strike against us.
         status = "repo-deleted"
@@ -488,7 +571,7 @@ def _ts(v):
     return v.isoformat() if hasattr(v, "isoformat") else str(v)
 
 
-def _format_body(post, repo_state=None):
+def _format_body(post, repo_state=None, sub_ban=None, sub_count=None):
     platform = post["platform"] or "?"
     status = post["status"] or "?"
     project = post["project_name"] or "(no project)"
@@ -505,6 +588,35 @@ def _format_body(post, repo_state=None):
 
     owner_block = ""
     repo_block = ""
+    reddit_block = ""
+    if platform == "reddit":
+        sub = _subreddit_from_url(thread_url) or _subreddit_from_url(our_url)
+        if sub:
+            n = sub_count if sub_count is not None else _subreddit_strike_count(sub)
+            count_line = (
+                f"Subreddit: r/{sub} ({n} of our post(s) moderated here in the "
+                f"last 90 days)\n"
+            )
+            if sub_ban == "banned":
+                ban_line = (
+                    f"Ban state: ACCOUNT BANNED from r/{sub} (deterministic "
+                    f"user_is_banned check). This is not a single-post removal: "
+                    f"every future post here will be removed. The sub is on the "
+                    f"comment_blocked denylist so the drafter will stop targeting "
+                    f"it, and a platform_banned learning signal feeds the digest.\n"
+                )
+            elif sub_ban == "not_banned":
+                ban_line = (
+                    f"Ban state: not banned (user_is_banned=false). This is a "
+                    f"single-post removal; the account can still post in r/{sub}.\n"
+                )
+            else:
+                ban_line = (
+                    f"Ban state: unknown (no live Reddit session for the check and "
+                    f"not on the recorded denylist). Treated as a single-post "
+                    f"removal until confirmed.\n"
+                )
+            reddit_block = count_line + ban_line
     if platform == "github" and thread_url:
         if repo_state == "repo_gone":
             repo_block = (
@@ -559,6 +671,7 @@ def _format_body(post, repo_state=None):
         f"Detected: {checked_at}\n"
         f"{repo_block}"
         f"{owner_block}"
+        f"{reddit_block}"
         f"\n"
         f"Thread:  {thread_url}\n"
         f"Title:   {title}\n"
@@ -567,20 +680,38 @@ def _format_body(post, repo_state=None):
         f"--- Our content ---\n"
         f"{content_preview}\n"
         f"\n"
-        f"--- Next steps ---\n"
-        f"1. Inspect the thread to see if the comment was deleted, hidden,\n"
-        f"   or if the whole account was blocked.\n"
-        f"2. If the owner should be hard-blocked, add it to\n"
-        f"   config.json -> exclusions.github_repos. Owner-level entries\n"
-        f"   match all repos under that owner.\n"
-        f"3. The auto-blocklist (github_tools._dynamic_owner_blocklist)\n"
-        f"   already covers any owner with >=2 strikes in 90 days.\n"
+        f"{_next_steps(platform)}"
         f"\n"
         f"To re-fire this alert: python3 scripts/strike_alert.py --post-id {post['id']}\n"
     )
     return _scrub_dashes(body)
 
 
+def _next_steps(platform):
+    if platform == "reddit":
+        return (
+            "--- Next steps ---\n"
+            "1. Ban state above is deterministic (logged-in user_is_banned).\n"
+            "   BANNED subs are auto-added to config.json subreddit_bans\n"
+            "   .comment_blocked and feed a platform_banned learning event;\n"
+            "   no manual action needed to stop targeting them.\n"
+            "2. A single-post removal is one community's judgment on the content;\n"
+            "   the platform_removed event already teaches the digest that\n"
+            "   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"
+        )
+    return (
+        "--- Next steps ---\n"
+        "1. Inspect the thread to see if the comment was deleted, hidden,\n"
+        "   or if the whole account was blocked.\n"
+        "2. If the owner should be hard-blocked, add it to\n"
+        "   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"
+    )
+
+
 def _send_email(subject, body):
     msg = MIMEText(body, "plain", "utf-8")
     msg["to"] = NOTIFICATION_EMAIL
@@ -651,6 +782,19 @@ def main():
         print("[strike_alert] no pending strikes")
         return
 
+    # Deterministic reddit ban verdict, computed ONCE for the whole sweep (a
+    # single read-only browser attach for all distinct subs, not one per email).
+    # Falls back to the recorded denylist when no session is reachable.
+    reddit_subs = {
+        s for s in (
+            _subreddit_from_url(r.get("thread_url")) or _subreddit_from_url(r.get("our_url"))
+            for r in rows if r.get("platform") == "reddit"
+        ) if s
+    }
+    reddit_ban = _reddit_ban_verdict(reddit_subs, _cfg, _reddit_username)
+    if reddit_subs:
+        print(f"[strike_alert] reddit_ban_verdict {reddit_ban}", flush=True)
+
     sent = 0
     skipped = 0
     filtered = 0
@@ -752,8 +896,13 @@ def main():
             )
             continue
 
-        subject = _format_subject(r, repo_state=repo_state)
-        body = _format_body(r, repo_state=repo_state)
+        _sub = None
+        _sub_ban = None
+        if r["platform"] == "reddit":
+            _sub = _subreddit_from_url(r.get("thread_url")) or _subreddit_from_url(r.get("our_url"))
+            _sub_ban = reddit_ban.get(_sub)
+        subject = _format_subject(r, repo_state=repo_state, sub_ban=_sub_ban)
+        body = _format_body(r, repo_state=repo_state, sub_ban=_sub_ban)
         if args.dry_run:
             print(f"[strike_alert] DRY RUN id={r['id']}")
             print(f"  subject: {subject}")