@m13v/s4l 1.7.6-rc.2 → 1.7.6-rc.21

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}")

package/scripts/test_no_silent_fallbacks.py

@@ -228,6 +228,7 @@ def check_account_resolver_hard_fails():
     import account_resolver  # noqa: E402
 
     saved_load_config = account_resolver._load_config
+    saved_durable_handle = account_resolver._durable_handle
     saved_env = dict(os.environ)
     try:
         # Strip every account-related env var + simulate an empty config.json
@@ -237,6 +238,15 @@ def check_account_resolver_hard_fails():
             if k.startswith("AUTOPOSTER_"):
                 del os.environ[k]
         account_resolver._load_config = lambda: {}
+        # Also stub the durable identity store (2026-07-17, added alongside
+        # account_resolver's _durable_handle): resolve() falls through to it
+        # as a THIRD source after env/config, so on any machine with a real
+        # twitter_cookie_mirror (this box included) "no config" alone no
+        # longer means "nothing resolvable" -- the real connected account's
+        # own handle would still come back and fail this "fresh install"
+        # simulation for the wrong reason. Stub it the same way _load_config
+        # is stubbed so this test isolates all three sources, not just one.
+        account_resolver._durable_handle = lambda key: None
 
         for platform in ("twitter", "reddit", "linkedin", "github", "moltbook"):
             result = account_resolver.resolve(platform)
@@ -258,6 +268,7 @@ def check_account_resolver_hard_fails():
               result == "some_handle", f"got {result!r}")
     finally:
         account_resolver._load_config = saved_load_config
+        account_resolver._durable_handle = saved_durable_handle
         os.environ.clear()
         os.environ.update(saved_env)
 

package/scripts/test_stall_watch_batch_progression.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""Regression test: the autopilot stall watchdog's batch-progression check must
+read the last N twitter_batches from the API envelope's data.batches, NOT the
+(nonexistent) top-level resp["batches"].
+
+Background (Nhat ae18af69, 07-15): http_api.api_get returns the RAW envelope
+{"ok":..,"data":{"batches":[..],"owner_host":..}} and does not unwrap "data".
+_recent_batches_not_progressing() read resp.get("batches") -> always None ->
+batches=[] -> len<min -> returned False on EVERY call. batches_stuck was thus
+hardwired False and the "drafting is not actually happening" stall cause could
+never be selected, so the watchdog mislabeled a real 30h phase2b-prep pileup as
+"orphaned routines / account change?". This locks in the correct key + the
+True/False logic so it cannot silently regress again.
+
+Run:  python3 scripts/test_stall_watch_batch_progression.py
+Exit 0 = all pass; non-zero with FAIL lines otherwise.
+"""
+from __future__ import annotations
+
+import importlib
+import os
+import sys
+import types
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+SCRIPTS = os.path.join(REPO, "scripts")
+# Source-tree test: pin S4L_REPO_DIR to THIS checkout so the function resolves
+# http_api from here, not an inherited installed-package path
+# (see gotcha_s4l_repo_dir_env_inherited_installed_package).
+os.environ["S4L_REPO_DIR"] = REPO
+if SCRIPTS not in sys.path:
+    sys.path.insert(0, SCRIPTS)
+
+asw = importlib.import_module("autopilot_stall_watch")
+MIN = asw.BATCH_PROGRESSION_MIN_BATCHES
+
+failures: list[str] = []
+
+
+def check(name: str, got, want) -> None:
+    ok = got == want
+    print(f"{'PASS' if ok else 'FAIL'}  {name}: got {got!r}, want {want!r}")
+    if not ok:
+        failures.append(name)
+
+
+def _fake_api(canned):
+    """Swap http_api for one whose api_get returns `canned` (or raises it, if a
+    BaseException). The function under test does `import http_api` lazily, so a
+    module planted in sys.modules wins."""
+    fake = types.ModuleType("http_api")
+
+    def api_get(path, query=None, ok_on_404=False):
+        if isinstance(canned, BaseException):
+            raise canned
+        return canned
+
+    fake.api_get = api_get
+    sys.modules["http_api"] = fake
+
+
+def envelope(phases):
+    """The real /api/v1/twitter-batches shape: batches nested under data."""
+    return {"ok": True, "data": {"owner_host": "test-host",
+                                 "batches": [{"current_phase": p} for p in phases]}}
+
+
+# 1. Last N batches ALL stuck at prep -> stall detected (the case that was missed).
+_fake_api(envelope(["phase2b-prep"] * MIN))
+check("all phase2b-prep -> batches_not_progressing True",
+      asw._recent_batches_not_progressing(), True)
+
+# 2. One of the last N reached real drafting -> not a stall.
+_fake_api(envelope(["phase2b-prep"] * (MIN - 1) + ["phase2b-gen"]))
+check("one phase2b-gen among last N -> False",
+      asw._recent_batches_not_progressing(), False)
+
+# 3. Fewer than N batches -> inconclusive, never page on thin history.
+_fake_api(envelope(["phase2b-prep"] * (MIN - 1)))
+check("fewer than MIN batches -> False",
+      asw._recent_batches_not_progressing(), False)
+
+# 4. THE REGRESSION GUARD: batches present ONLY at the wrong top-level key must be
+#    ignored. Correct code reads data.batches -> sees [] -> False. If someone
+#    "simplifies" back to resp.get("batches"), this flips to True and fails.
+_fake_api({"ok": True, "batches": [{"current_phase": "phase2b-prep"}] * MIN})
+check("top-level resp['batches'] ignored (must read data.batches)",
+      asw._recent_batches_not_progressing(), False)
+
+# 5. A terminal API failure (http_api raises SystemExit, a BaseException) must be
+#    swallowed to False, never crash this best-effort watchdog.
+_fake_api(SystemExit("terminal 5xx"))
+check("api SystemExit swallowed -> False",
+      asw._recent_batches_not_progressing(), False)
+
+if failures:
+    print(f"\n{len(failures)} FAILED: {failures}")
+    sys.exit(1)
+print("\nALL PASS")

package/scripts/top_performers.py

@@ -22,6 +22,12 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 MIN_CONTENT_LEN = 30  # skip posts with empty/placeholder content
 
+# Duplicated literal (not imported): must match draft_prompt_core.py's
+# STYLE_SENTINEL_TREATMENT and engagement_styles.py's STYLE_SENTINEL, both
+# of which independently define "voice_first" the same way ARM_TREATMENT's
+# "treatment_v4" is already duplicated across those two modules.
+STYLE_SENTINEL_TREATMENT = "voice_first"
+
 # CTE that adds a bot-filtered `clicks` column to every row of `posts`.
 # Sources from `post_link_clicks` (per-hit log, populated by the redirector
 # after 2026-05-07) with `is_bot=false`. This is the same attribution path
@@ -522,6 +528,24 @@ def _fetch_report_via_api(*, platform, project, top, bottom):
     raw_group = data.get("top_by_group") or {}
     top_by_style = data.get("top_by_style") or []
 
+    # treatment_v4 Twitter posts carry no real engagement style; they're
+    # stamped with the sentinel "voice_first" (must match
+    # draft_prompt_core.STYLE_SENTINEL_TREATMENT / engagement_styles.py's
+    # duplicated literal) instead of NULL, to avoid SQL NULL-handling
+    # landmines. This SQL-side GROUP BY has no whitelist, so without this
+    # filter "voice_first" would show up as its own row here, at roughly
+    # half of all Twitter post volume, and its single highest-scoring post
+    # would get presented as a "style to imitate" in the Best Example
+    # section below -- exactly the fake-style pollution this sentinel was
+    # designed to avoid downstream, just relocated to this report instead.
+    # Filtered here (not at the API) so every caller of this module is
+    # covered without touching the sibling website repo's SQL.
+    style_perf = [r for r in style_perf if r and r[0] != STYLE_SENTINEL_TREATMENT]
+    top_by_style = [
+        r for r in top_by_style
+        if not (len(r) > 12 and r[12] == STYLE_SENTINEL_TREATMENT)
+    ]
+
     top_filtered = _apply_top_filter(raw_top, top) if raw_top else []
     fallback_filtered = None
     if project and not top_filtered and raw_fallback:

package/scripts/twitter_browser.py

@@ -419,68 +419,38 @@ def _arm_self_liveness_watchdog():
 # _get_browser_and_page_raw, and find_twitter_cdp_port discovery. The
 # harness-profile discovery fallback stays as a belt for a closed tab.
 _PARK_URL = "https://x.com/robots.txt"
-_PARK_REGISTERED = False
 
 
 def _park_twitter_tabs():
-    try:
-        import urllib.request
+    # Thin alias kept for callers/tests; ONE implementation lives in
+    # scripts/browser_lifecycle.py (shared with reddit_browser.py — user
+    # directive 2026-07-17: share the machinery, don't fork failure points).
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    from browser_lifecycle import park_tabs
 
-        base = (
-            os.environ.get("TWITTER_CDP_URL", "").strip()
-            or "http://127.0.0.1:9555"
-        ).rstrip("/")
-        resp = urllib.request.urlopen(base + "/json/list", timeout=3)
-        targets = json.loads(resp.read())
-        for t in targets:
-            url = t.get("url", "")
-            if t.get("type") != "page":
-                continue
-            if "x.com" not in url and "twitter.com" not in url:
-                continue
-            if url.split("?", 1)[0].rstrip("/").endswith("/robots.txt"):
-                continue  # already parked
-            ws_url = t.get("webSocketDebuggerUrl")
-            if not ws_url:
-                continue
-            try:
-                import websocket
-
-                # suppress_origin: Chrome 111+ rejects CDP websocket clients
-                # that send an Origin header not in --remote-allow-origins
-                # (same pattern as restore_twitter_session.py).
-                ws = websocket.create_connection(
-                    ws_url, timeout=3, suppress_origin=True
-                )
-                try:
-                    ws.send(json.dumps({
-                        "id": 1,
-                        "method": "Page.navigate",
-                        "params": {"url": _PARK_URL},
-                    }))
-                    ws.recv()
-                finally:
-                    ws.close()
-                print(
-                    f"[twitter_browser] parked tab on {_PARK_URL} (was {url[:80]})",
-                    file=sys.stderr,
-                )
-            except Exception:
-                continue
-    except Exception:
-        pass
+    base = (
+        os.environ.get("TWITTER_CDP_URL", "").strip()
+        or "http://127.0.0.1:9555"
+    ).rstrip("/")
+    park_tabs(base, ("x.com", "twitter.com"), _PARK_URL, "twitter_browser")
 
 
 def _register_park_on_exit():
     """Arm parking once per process, only for processes that actually used the
     browser. Registered AFTER the module-level _release_browser_lock atexit,
     so it runs BEFORE it (LIFO): park while still holding the python lock,
-    then release. S4L_NO_TAB_PARK=1 is the escape hatch."""
-    global _PARK_REGISTERED
-    if _PARK_REGISTERED or os.environ.get("S4L_NO_TAB_PARK"):
-        return
-    _PARK_REGISTERED = True
-    atexit.register(_park_twitter_tabs)
+    then release. S4L_NO_TAB_PARK=1 is the escape hatch (honored inside
+    browser_lifecycle)."""
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    from browser_lifecycle import register_park_on_exit
+
+    base = (
+        os.environ.get("TWITTER_CDP_URL", "").strip()
+        or "http://127.0.0.1:9555"
+    ).rstrip("/")
+    register_park_on_exit(
+        base, ("x.com", "twitter.com"), _PARK_URL, "twitter_browser"
+    )
 
 
 def get_browser_and_page(playwright):

package/skill/archive-old-logs.sh

@@ -33,6 +33,30 @@ log "=== archive-old-logs starting (DAYS=$DAYS) ==="
 find "$LOG_DIR" -maxdepth 1 -type f -mtime +"$DAYS" ! -name "$(basename "$RUN_LOG")" -print0 \
   | xargs -0 -I{} mv {} "$ARCHIVE_DIR/" 2>&1 | tee -a "$RUN_LOG" >/dev/null || true
 
+# --- Size-based rotation for live launchd-*.log files (2026-07-17) -----------
+# launchd holds these fds open and appends forever, so the mtime sweep above
+# never touches them: their mtime is always fresh. Found in the wild at 1.9GB
+# (launchd-linkedin-stdout.log) and 694MB (launchd-engage-twitter-stdout.log),
+# which made "grep the logs" surface months-stale content as if it were
+# current (the 2026-07-17 Neon-hostname false alarm).
+# Copy-truncate: gzip the current content into logs-archive with a timestamp,
+# then truncate IN PLACE (same inode) so the launchd fd keeps appending.
+# Lines appended during the gzip window are lost on truncate; acceptable for
+# logs, and the window is seconds. Threshold tunable via ROTATE_MAX_MB.
+ROTATE_MAX_MB="${ROTATE_MAX_MB:-10}"
+find "$LOG_DIR" -maxdepth 1 -type f -name "launchd-*.log" -size +"${ROTATE_MAX_MB}M" -print0 \
+  | while IFS= read -r -d '' f; do
+      base=$(basename "$f" .log)
+      dest="$ARCHIVE_DIR/${base}-$(date +%Y%m%d-%H%M%S).log.gz"
+      if gzip -c "$f" > "$dest" 2>>"$RUN_LOG"; then
+        : > "$f"
+        log "rotated $(basename "$f") -> $(basename "$dest") ($(du -h "$dest" | cut -f1) compressed)"
+      else
+        rm -f "$dest"
+        log "WARN: rotate failed for $f (left untouched)"
+      fi
+    done
+
 remaining=$(find "$LOG_DIR" -maxdepth 1 -type f | wc -l | tr -d ' ')
 archived=$(find "$ARCHIVE_DIR" -maxdepth 1 -type f | wc -l | tr -d ' ')
 

package/skill/lib/reddit-backend.sh

@@ -153,6 +153,7 @@ ensure_reddit_browser_for_backend() {
     HC_WINDOW_POS="${BH_REDDIT_WINDOW_POS:-2131,-1032}" \
     HC_WINDOW_SIZE="${BH_REDDIT_WINDOW_SIZE:-911,1016}" \
     HC_PRE_LAUNCH_HOOK=_reddit_defer_if_posting \
+    HC_EXTRA_FLAGS="${BH_REDDIT_PROXY:+--proxy-server=$BH_REDDIT_PROXY}" \
     hc_ensure_browser
 }