@m13v/s4l 1.7.5-rc.44 → 1.7.5-rc.46

package/mcp/dist/index.js

@@ -1011,6 +1011,27 @@ async function postApproved(batchId, plan) {
                 plan = fresh;
         }
     }
+    // Arm the cross-instance posting flag HERE, before the Reddit drain, not just
+    // before the Twitter phase below. Root cause (found 2026-07-16): this flag
+    // used to get set only right before ensureTwitterBrowserForPost(), AFTER the
+    // whole Reddit drain loop above (one runPython("post_reddit.py") call per
+    // approved Reddit card, each with real CDP/browser overhead — a batch of a
+    // handful of cards routinely runs minutes). For that entire window this
+    // instance's isPeerDrainActive() reported false, so a SECOND MCP instance's
+    // postApproved() (e.g. a fresh one-shot worker boot running its own startup
+    // backlog drain) could pass the SAME gate check above and start its own
+    // drain concurrently. Both eventually reached their own Twitter phase and
+    // both spawned scripts/twitter_post_plan.py with S4L_LOCK_ROLE=post — the
+    // ONLY code path that ever sets that role. Two live "post" role holders
+    // can't preempt each other (browser_mutex.py case 6: correct, preempting a
+    // peer mid-post risks a double-post), so one always waited 45s and gave up
+    // — the "Twitter browser locked by session python:<pid> ... waited 45s,
+    // giving up" failures that silently killed 11 real approved drafts over
+    // 2026-07-15/16. Arming the flag for the FULL function closes that window:
+    // a peer's gate check now blocks for the entire drain, Reddit included, so
+    // only one instance ever reaches the Twitter phase at a time.
+    postingActive = true;
+    startPostingFlagHeartbeat();
     // Post every card the user APPROVED that hasn't already landed or been ruled out.
     // `approved` is now a DURABLE decision (sticky, never cleared by a later call), so
     // filtering out posted/terminal here makes this idempotent: re-running it only
@@ -1029,8 +1050,11 @@ async function postApproved(batchId, plan) {
             delete c.discard_reason;
         }
     }
-    if (approved.length === 0)
+    if (approved.length === 0) {
+        postingActive = false;
+        stopPostingFlagHeartbeat();
         return { attempted: 0, exit_code: 0, summary: "nothing approved" };
+    }
     // ---- Reddit cards (2026-07-14): drain them FIRST, independently ----------
     // A reddit card carries the verbatim draft decision (reddit_decision) plus
     // plan metadata (reddit_plan_meta), so approval reconstructs a one-decision
@@ -1204,7 +1228,10 @@ async function postApproved(batchId, plan) {
     }
     if (approvedTwitter.length === 0) {
         // All-reddit batch: persist the stamps and return without touching the
-        // twitter preflight/lock path.
+        // twitter preflight/lock path. Must clear the flag armed above ourselves —
+        // this branch never reaches the Twitter phase's scheduleShellLockRelease().
+        postingActive = false;
+        stopPostingFlagHeartbeat();
         if (redditSkippedPeerDrain) {
             return {
                 attempted: 0,
@@ -1230,6 +1257,8 @@ async function postApproved(batchId, plan) {
     if (!readConfiguredTwitterHandle())
         await ensurePostingHandle();
     if (!readConfiguredTwitterHandle()) {
+        postingActive = false;
+        stopPostingFlagHeartbeat();
         return {
             attempted: 0,
             exit_code: 0,
@@ -2863,7 +2892,22 @@ tool("post_drafts", {
             warnings,
         });
     }
-    const result = await postApproved(batch_id, plan);
+    // postApproved now arms the cross-instance posting flag before the Reddit
+    // drain (see its own comment), not just before the Twitter phase. Every
+    // op inside that drain is already individually best-effort try/caught, so
+    // this is belt-and-suspenders: if something still throws past all of
+    // that, clear the flag before it escapes rather than leave this MCP
+    // instance's posting permanently gated behind a flag nothing will ever
+    // reset.
+    let result;
+    try {
+        result = await postApproved(batch_id, plan);
+    }
+    catch (e) {
+        postingActive = false;
+        stopPostingFlagHeartbeat();
+        throw e;
+    }
     // Report the REAL posted count from the pipeline, not the approved count.
     // A run can approve N yet land 0 (browser/session failure); reporting
     // approve.size here told the agent "posted: N" on a total failure.
@@ -5658,6 +5702,10 @@ async function drainApprovedBacklog() {
     }
     catch (e) {
         console.error("[post] drainApprovedBacklog error:", e?.message || e);
+        // Same reasoning as the other postApproved call site: don't let an
+        // escaped exception leave the cross-instance posting flag stuck true.
+        postingActive = false;
+        stopPostingFlagHeartbeat();
     }
 }
 async function main() {

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.5-rc.44",
-  "installedAt": "2026-07-16T18:49:09.291Z"
+  "version": "1.7.5-rc.46",
+  "installedAt": "2026-07-16T19:12:33.534Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.5-rc.44",
+  "version": "1.7.5-rc.46",
   "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.5-rc.44",
+  "version": "1.7.5-rc.46",
   "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.5-rc.44",
+  "version": "1.7.5-rc.46",
   "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/feedback_digest.py

@@ -38,6 +38,14 @@ Loved approvals (the stronger emoji in the card's inline approve row:
 strength as an approve_level_N interaction, and are surfaced to the model
 as strong positive evidence.
 
+Platform-derived events (2026-07-16): each run first invokes
+scripts/platform_strike_events.py to sweep fresh moderation outcomes into the
+ledger (posts flipped to removed/deleted -> decision='platform_removed',
+project-scoped; community bans -> decision='platform_banned', project NULL).
+Project-scoped strikes flow through the normal per-project fetch; project-less
+bans ride along into every project's prompt like overall feedback, rendered in
+their own block. The prompt weighs both separately from human decisions.
+
 Failure handling: a Claude failure or unparseable plan leaves the events
 unprocessed for the next run. A run-level flock prevents concurrent digests.
 
@@ -185,7 +193,13 @@ def _event_line(e: dict) -> str:
         parts.append("edited_before_approving")
     line = " ".join(parts)
     if note:
-        line += f"\n  user note: {note[:300]}"
+        # Platform-derived events are machine-observed moderation facts, not
+        # something the user typed; label them honestly so the model never
+        # attributes the wording to the human reviewer.
+        label = ("moderation context"
+                 if str(e.get("decision") or "").startswith("platform_")
+                 else "user note")
+        line += f"\n  {label}: {note[:300]}"
     tweet = (e.get("tweet_text") or "").strip()
     if tweet:
         line += f"\n  their post was: {tweet[:200]}"
@@ -222,13 +236,17 @@ def _no_reason_rejects(events: list[dict]) -> list[dict]:
             and not (e.get("reject_note") or "").strip()]
 
 
-def build_prompt(project: dict, events: list[dict], overall_events: list[dict] | None = None) -> str:
+def build_prompt(project: dict, events: list[dict], overall_events: list[dict] | None = None,
+                 platform_events: list[dict] | None = None) -> str:
     block = lp.get_block(project)
     overall_events = overall_events or []
+    platform_events = platform_events or []
     rejected = [e for e in events if e.get("decision") == "rejected"]
     no_reason = _no_reason_rejects(events)
     approved = [e for e in events if e.get("decision") == "approved"]
     loved = [e for e in approved if e.get("loved")]
+    plat_removed = [e for e in events
+                    if str(e.get("decision") or "").startswith("platform_")]
     voice_never = ((project.get("voice") or {}).get("never")) or []
     guard_do_not = ((project.get("content_guardrails") or {}).get("do_not")) or []
 
@@ -247,6 +265,17 @@ def build_prompt(project: dict, events: list[dict], overall_events: list[dict] |
             "explicit standing guidance about the whole pipeline, NOT about any single thread):\n"
             f"{notes}"
         )
+    platform_block = ""
+    if platform_events:
+        plat_lines = "\n".join(
+            f"{i + 1}. {_event_line(e)}" for i, e in enumerate(platform_events)
+        )
+        platform_block = (
+            f"\n\nPLATFORM-DERIVED ACCOUNT-LEVEL SIGNALS ({len(platform_events)} "
+            "event(s), machine-observed, not tied to one project; they ride into "
+            "every project's digest like overall feedback):\n"
+            f"{plat_lines}"
+        )
 
     return f"""You maintain the SINGLE, install-wide learned_preferences block for this social-posting pipeline (shared across every configured project, not just "{project.get('name')}"). It distills the user's own approve/reject decisions on draft cards into short standing preferences that steer future thread selection and drafting across ALL projects. It is SOFT guidance read by the drafting model, not a filter.
 
@@ -258,13 +287,15 @@ CURRENT learned_preferences (shared by every project):
 CURRENT voice.never: {json.dumps(voice_never)}
 CURRENT content_guardrails.do_not: {json.dumps(guard_do_not)}
 
-NEW REVIEW EVENTS since the last digest ({len(rejected)} rejected, {len(no_reason)} of the rejects without a stated reason, {len(approved)} approved, {len(loved)} of the approvals loved):
-{ev_lines}{overall_block}
+NEW REVIEW EVENTS since the last digest ({len(rejected)} rejected, {len(no_reason)} of the rejects without a stated reason, {len(approved)} approved, {len(loved)} of the approvals loved, {len(plat_removed)} platform moderation strikes):
+{ev_lines}{overall_block}{platform_block}
 
 Categories: wrong_author = the thread's author/audience was a bad fit; off_topic = the thread itself was a bad fit; bad_draft = thread was fine but the written reply was off; other = see the note. "no_reason_given" means the user rejected without picking a category or typing a note: the rejection itself is real, but WHY is your inference from the author/thread/draft context alone, so treat it as weak evidence. It can corroborate a pattern that reasoned events already show, but a no_reason_given reject never justifies a new entry or an author block on its own, and 2+ of them agreeing still only justify an entry when the shared pattern in their context is unmistakable. "edited_before_approving" with an ORIGINAL/REWROTE pair means the user hand-corrected our draft before posting: the rewrite is a direct statement of the voice they want. Diff the pair; when 2+ edits show the same correction (a phrase type removed, a structure replaced, tone shifted, length cut), distill that recurring pattern into draft_style_notes. Ignore edit content that is lead-specific or cosmetic (typo fixes, one-off facts); learn only what generalizes. "user_checked=profile_click" means the user opened the author's profile before deciding (a strong author-quality signal even without a note). "[approved+loved]" means the user picked the heart in the approve row ("this was a really good one"; approve_level_N in interactions carries the strength, 2 = best of the best): strong positive evidence for audience_prefer and thread selection, worth roughly two plain approvals.
 
 Two-draft cards show a "did NOT pick" pair. "picked_draft_b_over_default_a" means the card offered two drafts with A preselected and the user deliberately clicked into B and approved it: a direct head-to-head preference for the picked draft over the shown alternative, evidence on par with a hand rewrite. "chose_default_a_after_trying_b" means they clicked into B (trying it as the selection) and then came back and approved A: equally explicit, the same head-to-head strength as a switch, just with the default as the winner. "kept_default_a_after_reading_b=Xs" means they kept the preselected A but spent Xs with the pointer over B first: an informed keep, weaker than either explicit choice (reading B does not prove they weighed it; treat like no_reason_given, corroborating a pattern that stronger events already show rather than founding one). "second_draft_not_read" means they approved the default without touching or reading the alternative: NO pairwise signal, never infer anything against the unread draft. When 2+ pairwise events agree, diff the picked texts against the not-picked ones and distill WHAT recurs (tone, structure, length, opener type, directness) into draft_style_notes; the "styles:" line names each side's engagement style, useful when the same style keeps winning or losing.
 
+"[platform_removed]" and "[platform_banned]" events are MACHINE-DERIVED moderation outcomes, not human card decisions; weigh them on their own track, never as a statement of the reviewer's taste. platform_removed means a moderator or platform filter removed one of our posts: the lesson is the CONTENT pattern (what reads as promotional, off-topic, or AI-written in that kind of venue), feeding thread_avoid or draft_style_notes. One removal is one community's judgment: treat it like a reasoned reject (it may justify one narrowly-scoped entry since the moderation context states the venue and outcome explicitly), and generalize only when 2+ removals share a pattern. platform_banned means a community blocked our account outright: the strongest platform-side evidence, but the specific venue is ALREADY hard-blocked by the pipeline, so never spend an entry naming an individual community; the only lesson worth an entry is a venue TYPE pattern (e.g. what kinds of communities keep rejecting us) once 2+ bans or removals show it. Platform events never justify block_authors (there is no author at fault) and never touch audience_prefer.
+
 You can also block SPECIFIC authors via the plan's block_authors list. A block is a permanent hard exclusion of that one handle from all future thread selection, so it is YOUR judgment call, never automatic. Block when the evidence is strong: a wrong_author reject IS a direct human statement about that author (especially with profile_click), and the author context (author_followers, their post, found_via_topic) or the user's note confirms the account itself was the problem rather than the topic. Do NOT block when the reject looks topic-driven (off_topic/bad_draft on a reasonable account) or when you are unsure; the generalizable TYPE entry in audience_avoid is the softer tool for that.
 
 Propose changes to the block. RULES, in priority order:
@@ -413,18 +444,21 @@ def _is_actionable(e: dict) -> bool:
 
 
 def digest_project(project: dict, platform: str, dry_run: bool,
-                   overall_events: list[dict] | None = None) -> bool:
-    """Digest one project's pending events (plus any overall-feedback notes,
-    which ride along in every project's prompt but are marked processed by
-    main(), not here). Returns True when the digest completed (or there was
-    nothing to do); False leaves the events unprocessed for the next run."""
+                   overall_events: list[dict] | None = None,
+                   platform_events: list[dict] | None = None) -> bool:
+    """Digest one project's pending events (plus any overall-feedback notes
+    and account-level platform events, which ride along in every project's
+    prompt but are marked processed by main(), not here). Returns True when
+    the digest completed (or there was nothing to do); False leaves the
+    events unprocessed for the next run."""
     name = project.get("name")
     overall_events = overall_events or []
+    platform_events = platform_events or []
     resp = api_get("/api/v1/review-events",
                    {"project": name, "platform": platform, "unprocessed": "true",
                     "limit": str(MAX_EVENTS_PER_RUN)})
     events = ((resp or {}).get("data") or {}).get("events") or []
-    if not events and not overall_events:
+    if not events and not overall_events and not platform_events:
         return True
     no_reason = _no_reason_rejects(events)
     if len(no_reason) >= BULK_NO_REASON_THRESHOLD:
@@ -433,13 +467,14 @@ def digest_project(project: dict, platform: str, dry_run: bool,
             f"count={len(no_reason)} threshold={BULK_NO_REASON_THRESHOLD} "
             f"event_ids=[{ids}] (volume signal, logged regardless of whether "
             "the digest model finds a shared textual pattern below)")
-    if not overall_events and not any(_is_actionable(e) for e in events):
+    if not overall_events and not platform_events and not any(_is_actionable(e) for e in events):
         log(f"project={name} platform={platform} events={len(events)} "
             "plain_approvals_only, no digest (they ride along with the next actionable event)")
         return True
-    prompt = build_prompt(project, events, overall_events)
+    prompt = build_prompt(project, events, overall_events, platform_events)
     if dry_run:
-        log(f"project={name} platform={platform} events={len(events)} overall={len(overall_events)} DRY RUN prompt below")
+        log(f"project={name} platform={platform} events={len(events)} overall={len(overall_events)} "
+            f"platform_ridealong={len(platform_events)} DRY RUN prompt below")
         print(prompt)
     ok, out, err = call_claude(prompt)
     if not ok:
@@ -567,6 +602,18 @@ def main() -> int:
         except Exception as e:
             log(f"learned_preferences migration error (non-fatal): {e}")
 
+    # Platform-strike sweep (2026-07-16): pull fresh moderation outcomes
+    # (removed/deleted posts, community bans) into the ledger before reading
+    # it, so this very run digests them. Idempotent (deterministic
+    # event_uuid), non-fatal, and skipped on --dry-run (which promises to
+    # change nothing).
+    if not args.dry_run:
+        try:
+            import platform_strike_events
+            platform_strike_events.sweep()
+        except Exception as e:
+            log(f"platform_strike_sweep_error (non-fatal): {e}")
+
     cfg = load_config()
     by_name = {p.get("name"): p for p in (cfg.get("projects") or [])}
 
@@ -577,20 +624,28 @@ def main() -> int:
     # button / menu bar "Send feedback…"): fetched once, folded into EVERY
     # configured project's prompt, and marked processed only after all
     # attempted digests succeed (apply_mutations dedups any re-digest).
+    # Project-less platform events (community bans, account-level by nature)
+    # ride along the same way but render in their own prompt block.
     overall_events: list[dict] = []
+    platform_events: list[dict] = []
     try:
         oresp = api_get("/api/v1/review-events",
                         {"unprocessed": "true", "limit": "100"})
-        overall_events = [
-            e for e in (((oresp or {}).get("data") or {}).get("events") or [])
-            if e.get("decision") == "feedback" and not e.get("project")
-        ]
+        for e in (((oresp or {}).get("data") or {}).get("events") or []):
+            if e.get("project"):
+                continue
+            if e.get("decision") == "feedback":
+                overall_events.append(e)
+            elif str(e.get("decision") or "").startswith("platform_"):
+                platform_events.append(e)
     except Exception as e:
         log(f"overall_feedback_fetch_error={e}")
     if overall_events:
         log(f"overall feedback notes pending: {len(overall_events)}")
+    if platform_events:
+        log(f"account-level platform events pending: {len(platform_events)}")
 
-    if not counts and not overall_events:
+    if not counts and not overall_events and not platform_events:
         log("no unprocessed review events")
         return 0
 
@@ -603,12 +658,13 @@ def main() -> int:
         n = int(row.get("unprocessed") or 0)
         if args.project and name != args.project:
             continue
-        # Explicit overall feedback shouldn't wait on the card-event threshold.
-        if n < args.min_events and not overall_events:
+        # Explicit overall feedback / platform events shouldn't wait on the
+        # card-event threshold.
+        if n < args.min_events and not overall_events and not platform_events:
             log(f"project={name} platform={platform} events={n} below_min={args.min_events}, waiting")
             continue
         todo[(name, platform)] = n
-    if overall_events:
+    if overall_events or platform_events:
         for name in by_name:
             if args.project and name != args.project:
                 continue
@@ -623,28 +679,30 @@ def main() -> int:
             continue
         attempted += 1
         try:
-            if not digest_project(proj, platform, args.dry_run, overall_events):
+            if not digest_project(proj, platform, args.dry_run, overall_events,
+                                  platform_events):
                 failures += 1
         except Exception as e:
             failures += 1
             log(f"project={name} digest_error={e}")
 
-    if overall_events and not args.dry_run:
+    ridealong = overall_events + platform_events
+    if ridealong and not args.dry_run:
         if attempted and not failures:
-            ids = [int(e["id"]) for e in overall_events
+            ids = [int(e["id"]) for e in ridealong
                    if str(e.get("id", "")).isdigit() or isinstance(e.get("id"), int)]
             try:
                 presp = api_patch("/api/v1/review-events",
                                   {"ids": ids, "action": "mark_processed",
                                    "processed_batch": f"digest-overall-{_now_stamp()}"})
                 marked = ((presp or {}).get("data") or {}).get("updated") or 0
-                log(f"overall feedback marked processed: {marked}")
+                log(f"overall/platform ride-along events marked processed: {marked}")
             except Exception as e:
                 log(f"overall mark_processed_failed={e} (re-digested next run; apply dedups)")
         elif attempted:
-            log("overall feedback left unprocessed (a project digest failed; next run retries)")
+            log("overall/platform events left unprocessed (a project digest failed; next run retries)")
         else:
-            log("overall feedback pending but no configured project to digest into; left unprocessed")
+            log("overall/platform events pending but no configured project to digest into; left unprocessed")
     return 0
 
 

package/scripts/platform_strike_events.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""Sweep platform moderation strikes into the review_events ledger.
+
+Two platform-derived decision types (2026-07-15 design, see
+migrations/2026-07-15-review-platform-events.sql in the website repo):
+
+  platform_removed  A post of ours flipped to status='removed'/'deleted'
+                    (moderator removal, automod filter, or platform spam
+                    filter). One event per post. Less severe: the lesson
+                    is the CONTENT pattern, not the venue.
+  platform_banned   Our account is blocked from a community (config.json
+                    subreddit_bans.comment_blocked, reason
+                    'account_blocked_in_sub'). One event per (sub, account).
+                    Severe: strong evidence against the venue. Emitted with
+                    project=NULL (the ban is account-level, not tied to one
+                    project); the digest folds these into every project's
+                    prompt like overall feedback.
+
+Idempotency: event_uuid is a uuid5 of the source fact (post id / sub+account),
+NOT salted per install or per run, so re-runs AND concurrent sweeps from
+sibling installs of the same fleet all collapse into one ledger row via the
+API's ON CONFLICT (event_uuid) DO NOTHING.
+
+Scoping: only posts whose project_name appears in the LOCAL config.json are
+swept. This file ships in the release, so a customer install must never
+mint events for other installs' posts; the local project list is exactly
+the boundary of what this box is allowed to learn from. (posts GET is
+deliberately fleet-wide, so own_install=true would drop the operator's
+pre-install-stamping rows; the project filter is the correct scope.)
+
+Recency gate: only posts DETECTED removed recently (status_checked_at within
+--window-days, default 14) and bans ADDED within the same window. Removal
+detection was dead 2026-05-28 to 2026-07-14, so without the gate the first
+sweep would flood the digest with months of ancient history. Only rows with
+deletion_detect_count >= 2 qualify (the same two-strike confirmation the
+strike-alert email rail requires).
+
+Invoked automatically at the start of every feedback_digest.py run (skipped
+on --dry-run), or manually:
+
+    python3 scripts/platform_strike_events.py [--window-days N] [--dry-run]
+
+stderr marker (load-bearing shape, keep stable):
+    [platform_strike_events] swept=... removed_events=... ban_events=... inserted=... duplicates=...
+"""
+from __future__ import annotations
+
+import argparse
+import datetime
+import json
+import os
+import re
+import sys
+import uuid
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from http_api import api_get, api_post, load_env  # noqa: E402
+# Stable namespace for deterministic event uuids. Never change this value:
+# a new namespace would re-mint every historical fact as a "new" event.
+EVENT_NS = uuid.uuid5(uuid.NAMESPACE_URL, "https://s4l.ai/platform-strike-events")
+POST_BATCH = 100  # review-events POST MAX_BATCH
+FETCH_LIMIT = 500  # posts GET hard cap; newest-first covers all fresh flips
+MAX_NOTE = 1900  # route clips reject_note at 2000; stay under
+MAX_DRAFT = 9500
+
+
+def log(msg: str) -> None:
+    print(f"[platform_strike_events] {msg}", file=sys.stderr, flush=True)
+
+
+def _now() -> datetime.datetime:
+    return datetime.datetime.now(datetime.timezone.utc)
+
+
+def _parse_ts(raw) -> datetime.datetime | None:
+    if not raw:
+        return None
+    try:
+        return datetime.datetime.fromisoformat(str(raw).replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
+def _load_config() -> dict:
+    """Same resolution as the digester (state-dir first, symlinks resolved),
+    so producer scope and digest scope can never disagree."""
+    try:
+        from config import config_path
+        return json.loads(Path(config_path()).read_text())
+    except Exception:
+        return {}
+
+
+def _venue(post: dict) -> str | None:
+    """Human-readable venue for the note: subreddit for reddit, repo for
+    github, otherwise nothing (twitter has no venue concept)."""
+    url = post.get("thread_url") or post.get("our_url") or ""
+    m = re.search(r"reddit\.com/r/([^/]+)/", url)
+    if m:
+        return f"r/{m.group(1)}"
+    m = re.search(r"github\.com/([^/]+/[^/#?]+)", url)
+    if m:
+        return m.group(1)
+    return None
+
+
+def _removed_event(post: dict) -> 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]
+    note = (
+        f"Platform moderation strike: our {post.get('platform')} {kind}"
+        f"{' in ' + venue if venue else ''} is now status='{post.get('status')}'"
+        f" (confirmed on {post.get('deletion_detect_count')} consecutive scans)."
+        f" Posted {posted}, removal detected {detected},"
+        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."
+    )
+    return {
+        "event_uuid": str(uuid.uuid5(EVENT_NS, f"platform_removed:post:{post['id']}")),
+        "decision": "platform_removed",
+        "platform": post.get("platform") or "reddit",
+        "project": post.get("project_name"),
+        "thread_url": (post.get("our_url") or post.get("thread_url") or "")[:1000] or None,
+        "thread_author": post.get("thread_author"),
+        "draft_text": (post.get("our_content") or "")[:MAX_DRAFT] or None,
+        "reject_note": note[:MAX_NOTE],
+        "batch_id": "platform_strike_sweep",
+    }
+
+
+def _ban_event(entry: dict) -> dict:
+    sub = str(entry.get("sub") or "").strip().lower()
+    account = str(entry.get("account") or "").strip()
+    added = str(entry.get("added_at") or "")[:10]
+    note = (
+        f"Community ban: our reddit account {account or '(unknown)'} is blocked"
+        f" from participating in r/{sub} (reason: {entry.get('reason')},"
+        f" noticed {added or 'unknown date'})."
+        f" Machine-derived signal: the venue itself rejected the account,"
+        f" the strongest platform-side evidence against this venue/content pairing."
+    )
+    return {
+        "event_uuid": str(uuid.uuid5(EVENT_NS, f"platform_banned:reddit:{sub}:{account.lower()}")),
+        "decision": "platform_banned",
+        "platform": "reddit",
+        "project": entry.get("noticed_by_project") or None,
+        "thread_url": f"https://www.reddit.com/r/{sub}/" if sub else None,
+        "reject_note": note[:MAX_NOTE],
+        "batch_id": "platform_strike_sweep",
+    }
+
+
+def collect_events(window_days: int) -> 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")}
+    cutoff = _now() - datetime.timedelta(days=window_days)
+
+    resp = api_get("/api/v1/posts", {
+        "statuses": "removed,deleted",
+        "order_by": "id",
+        "order_dir": "desc",
+        "limit": str(FETCH_LIMIT),
+    })
+    posts = ((resp or {}).get("data") or {}).get("posts") or []
+
+    removed_events = []
+    for p in posts:
+        if p.get("project_name") not in local_projects:
+            continue
+        if int(p.get("deletion_detect_count") or 0) < 2:
+            continue
+        detected = _parse_ts(p.get("status_checked_at"))
+        if detected is None or detected < cutoff:
+            continue
+        removed_events.append(_removed_event(p))
+
+    ban_events = []
+    for entry in ((cfg.get("subreddit_bans") or {}).get("comment_blocked") or []):
+        if entry.get("reason") != "account_blocked_in_sub":
+            continue
+        added = _parse_ts(entry.get("added_at"))
+        if added is None or added < cutoff:
+            continue
+        ban_events.append(_ban_event(entry))
+
+    return removed_events + ban_events, len(removed_events), len(ban_events)
+
+
+def sweep(window_days: int = 14, dry_run: bool = False) -> dict:
+    events, n_removed, n_banned = collect_events(window_days)
+    inserted = 0
+    duplicates = 0
+    if dry_run:
+        for ev in events:
+            print(json.dumps(ev, indent=2))
+    else:
+        for i in range(0, len(events), POST_BATCH):
+            resp = api_post("/api/v1/review-events", {"events": events[i:i + POST_BATCH]})
+            data = (resp or {}).get("data") or {}
+            inserted += int(data.get("inserted") or 0)
+            duplicates += int(data.get("duplicates") or 0)
+    log(
+        f"swept={len(events)} removed_events={n_removed} ban_events={n_banned}"
+        f" inserted={inserted} duplicates={duplicates}"
+        f"{' (dry run, nothing posted)' if dry_run else ''}"
+    )
+    return {"swept": len(events), "removed": n_removed, "banned": n_banned,
+            "inserted": inserted, "duplicates": duplicates}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("--window-days", type=int,
+                    default=int(os.environ.get("S4L_PLATFORM_STRIKE_WINDOW_DAYS", "14")),
+                    help="sweep strikes detected within the last N days")
+    ap.add_argument("--dry-run", action="store_true",
+                    help="print the events instead of posting them")
+    args = ap.parse_args()
+    load_env()
+    sweep(args.window_days, args.dry_run)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())