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

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/reddit_browser.py

@@ -341,6 +341,29 @@ def _touch_browser_heartbeat(*_args):
         pass
 
 
+def _register_reddit_park_on_exit(cdp_base=""):
+    """Shared tab lifecycle (2026-07-17 unification): park reddit tabs on
+    reddit's own /robots.txt at process exit — the SAME single implementation
+    twitter_browser uses (scripts/browser_lifecycle.py). Static page = no SPA
+    to leak/crash while idle, URL still matches the reddit.com reuse
+    preference above so no new tabs (Target.createTarget is the proven
+    focus-steal trigger). S4L_NO_TAB_PARK=1 escape hatch inside the module.
+    Best-effort: parking must never fail an attach."""
+    try:
+        sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+        from browser_lifecycle import register_park_on_exit
+
+        register_park_on_exit(
+            (cdp_base or os.environ.get("REDDIT_CDP_URL", "").strip()
+             or "http://127.0.0.1:9557").rstrip("/"),
+            ("reddit.com",),
+            "https://www.reddit.com/robots.txt",
+            "reddit_browser",
+        )
+    except Exception:
+        pass
+
+
 def get_browser_and_page(playwright):
     """Instrumented entry point: attach via _get_browser_and_page_raw, then
     (L1) set default per-op/navigation timeouts so no page call can hang
@@ -395,6 +418,7 @@ def _get_browser_and_page_raw(playwright):
         try:
             cdp_browser = playwright.chromium.connect_over_cdp(cdp_url_env)
             _bh_activity_log("attach_harness", cdp_url_env)
+            _register_reddit_park_on_exit(cdp_url_env)
             # Prefer a context that already carries a live reddit_session; else
             # fall back to the first context (harness is single-profile, logged in).
             chosen = None

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/setup_twitter_auth.py

@@ -61,14 +61,8 @@ except ImportError:
         "websocket-client not installed (needed for CDP). pip install websocket-client"
     )
 
-# Live-handle resolver (best-effort). Lets connect_x record the real logged-in
-# @handle alongside the locally-mirrored cookies. Guarded so a missing dep never
-# breaks setup.
+# Make scripts-dir siblings (twitter_cookie_mirror, etc.) importable during setup.
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-try:
-    from twitter_account import resolve_handle  # noqa: E402
-except Exception:
-    resolve_handle = None
 
 # Local 0600 cookie mirror — the keychain-independent durability layer (Gap B).
 # Always importable (stdlib only); guarded so a path quirk never breaks setup.
@@ -345,12 +339,12 @@ _HANDLE_PLACEHOLDERS = {"", "your-twitter-handle", "@your-twitter-handle"}
 def _resolve_live_handle(send) -> "str | None":
     """Read the logged-in @handle from the LIVE x.com session.
 
-    resolve_handle() only reads config.json (which on a fresh install is the
-    template placeholder), so it can't discover the real account. This reads the
-    actual logged-in handle from the SAME authenticated session connect_x just
-    validated, so connect_x / cmd_resolve_handle can persist ground truth instead
-    of falling back to a hardcoded handle (which would silently mis-attribute
-    every post). Two methods, most reliable first:
+    On a fresh install config.json carries no handle yet, so this reads the actual
+    logged-in handle from the SAME authenticated session connect_x just validated
+    and stamps it on the durable cookie mirror (see _persist_session). That mirror
+    is what account_resolver.resolve('twitter') falls back to, so attribution is
+    ground truth instead of a hardcoded handle that would silently mis-attribute
+    every post. Two methods, most reliable first:
 
       1. X's own account/settings.json (canonical `screen_name`). The web client
          calls this on every load; it is stable across DOM redesigns, unlike the
@@ -405,41 +399,6 @@ def _resolve_live_handle(send) -> "str | None":
     return None
 
 
-def _write_handle_to_config(handle: "str | None") -> bool:
-    """Persist the discovered handle to config.json accounts.twitter.handle, but
-    ONLY when the configured value is empty or the template placeholder, so we
-    never clobber a handle the user set on purpose. Returns True if written.
-
-    This is what makes account_resolver.resolve('twitter') return the REAL
-    account, so our_account (attribution, own-reply skip, account-keyed ops) is
-    correct instead of the poisonous 'your-twitter-handle' default. (2026-06-02)
-    """
-    if not handle:
-        return False
-    try:
-        with open(_CONFIG_JSON, encoding="utf-8") as f:
-            cfg = json.load(f)
-    except Exception:
-        return False
-    accounts = cfg.setdefault("accounts", {})
-    if not isinstance(accounts, dict):
-        return False
-    tw = accounts.setdefault("twitter", {})
-    if not isinstance(tw, dict):
-        return False
-    cur = (tw.get("handle") or "").strip()
-    if cur.lower() not in _HANDLE_PLACEHOLDERS:
-        return False  # a real handle is already set; do not overwrite
-    tw["handle"] = "@" + handle.lstrip("@")
-    try:
-        with open(_CONFIG_JSON, "w", encoding="utf-8") as f:
-            json.dump(cfg, f, indent=2)
-            f.write("\n")
-        return True
-    except Exception:
-        return False
-
-
 def _persist_session() -> None:
     """Persist the validated live X session for auto-restore after ANY logout
     (hard kill, crash, or a keychain re-lock wiping Chrome's Cookies DB).
@@ -479,17 +438,15 @@ def _persist_session() -> None:
     if not cookies:
         return
 
-    # Fall back to the configured handle if live resolution came up empty.
-    if handle and _write_handle_to_config(handle):
-        print(f"setup_twitter_auth: recorded live X handle @{handle} in config.json "
-              "(accounts.twitter.handle); attribution + own-reply dedup now scoped "
-              "to the real account", file=sys.stderr)
-    if not handle and resolve_handle is not None:
-        try:
-            handle = resolve_handle()
-        except Exception:
-            handle = None
-
+    # The handle's single durable home is the cookie mirror (written just below).
+    # We deliberately do NOT also copy it into config.json: account_resolver
+    # resolves env -> config override -> this mirror, so a second copy in config
+    # would be duplicated state that can drift — and its going missing there was the
+    # "posts land 0/N, no_account_configured" bug. config.accounts.twitter.handle
+    # stays a user-only override. When live resolution came up empty, save_cookies
+    # carries the previously-stamped handle forward, so a known account is never
+    # downgraded to null.
+    #
     # Local mirror — keychain-independent durability. This is the only cookie
     # store; the VM-era server store (/api/v1/twitter/session-cookies) was
     # removed 2026-06-17 when we stopped running AppMaker VMs.
@@ -499,6 +456,10 @@ def _persist_session() -> None:
             print(f"setup_twitter_auth: mirrored {n} x.com cookies to "
                   f"{twitter_cookie_mirror.MIRROR_PATH} (survives keychain re-lock "
                   "/ Cookies-DB wipe on relaunch)", file=sys.stderr)
+            if handle:
+                print(f"setup_twitter_auth: durable X handle @{handle} stamped on the "
+                      "cookie mirror; account_resolver resolves it for attribution + "
+                      "own-reply dedup", file=sys.stderr)
         except Exception as e:
             print(f"setup_twitter_auth: local mirror save skipped ({e})", file=sys.stderr)
 
@@ -1303,37 +1264,6 @@ def cmd_connect(args) -> dict:
     }
 
 
-def cmd_resolve_handle(args) -> dict:
-    """Read the live logged-in @handle from the managed Chrome and persist it to
-    config.json accounts.twitter.handle.
-
-    The MCP post preflight calls this to self-heal a missing handle — the onboarding
-    gap where connect_x's best-effort live-DOM read silently no-op'd, leaving the
-    install logged in but with accounts:null, so twitter_browser.py refused EVERY
-    reply with no_account_configured. Reading the handle from the SAME session the
-    poster posts through is ground truth, not a guess, so it's safe where a hardcoded
-    fallback would not be. Best-effort: returns state=browser_not_running / no_handle
-    on failure and never raises."""
-    try:
-        ws, send = _attach()
-    except Exception as e:
-        return {"ok": False, "state": "browser_not_running", "error": str(e)}
-    handle = None
-    try:
-        handle = _resolve_live_handle(send)
-    except Exception:
-        handle = None
-    finally:
-        try:
-            ws.close()
-        except Exception:
-            pass
-    if not handle:
-        return {"ok": False, "state": "no_handle"}
-    persisted = _write_handle_to_config(handle)
-    return {"ok": True, "state": "resolved", "handle": handle, "persisted": persisted}
-
-
 def main() -> int:
     ap = argparse.ArgumentParser(description="Twitter/X session bootstrap for MCP setup.")
     sub = ap.add_subparsers(dest="cmd", required=True)
@@ -1341,10 +1271,6 @@ def main() -> int:
     sub.add_parser("detect-sources",
                    help="List browsers/profiles to import the X session from "
                         "(JSON, for the panel dropdown). No keychain prompt.")
-    sub.add_parser("resolve-handle",
-                   help="Read the live logged-in @handle from the managed Chrome and "
-                        "persist it to config.json accounts.twitter.handle. Idempotent "
-                        "self-heal for the post preflight; never overwrites a real handle.")
     c = sub.add_parser("connect", help="Ensure browser + import/validate the X session.")
     c.add_argument("--source", default=None,
                    help="Browser profile to import from (e.g. chrome:Default, arc:Default), "
@@ -1375,8 +1301,6 @@ def main() -> int:
         out = {"ok": False, "state": "error", "error": _WEBSOCKET_IMPORT_ERROR}
     elif args.cmd == "status":
         out = cmd_status(args)
-    elif args.cmd == "resolve-handle":
-        out = cmd_resolve_handle(args)
     else:
         out = cmd_connect(args)
     print(json.dumps(out, indent=2))

package/scripts/store_patch.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""Locked field-patcher for the review-queue store.
+
+The review store (review-queue.json) has three writers: the menubar
+(s4l_state._store_update), merge_review_queue.py, and the MCP server. The
+first two hold an fcntl.flock on `<store>.lock` around their read-modify-write;
+the MCP server is Node, which has no native flock, so it routes its store
+writes through THIS script instead of writing the file itself. That closes the
+last unlocked writer (the last-writer-wins race that erased posted stamps on
+2026-07-17 — six live replies rendered as duplicate_thread_pre_post kills).
+
+Protocol-compatible with s4l_state._store_update: same lock file, LOCK_EX for
+the whole read-mutate-replace span, atomic os.replace. fcntl (not an O_EXCL
+lockfile) on purpose: the kernel drops the lock when the holder dies, so there
+is no stale-lock stealing logic to get wrong.
+
+Usage: store_patch.py <patches.json>   (or '-' to read the JSON from stdin)
+
+Input shape:
+  {"patches": [
+      {"candidate_id": 123,          # match ALL rows with this id (ids are NOT
+                                     # unique: sandbox reruns/variant drafts
+                                     # append sibling rows; a stamp that hits
+                                     # only one sibling leaves a drainable twin)
+       "n": 4,                       # 1-based index fallback when candidate_id
+                                     # is absent/None (legacy rows)
+       "set":   {"approved": true},  # fields to assign
+       "unset": ["discard_reason"]}  # fields to delete
+  ]}
+
+Merge rules (mirror mergeApprovedStampsIntoStore):
+  - posted is sticky: a patch may set posted=true, but `set.terminal=true` is
+    ignored on a row whose posted is already true, and posted is never unset.
+Prints {"ok": true, "patched": N} on stdout. Exit 0 even when N=0 (a patch
+matching nothing is not an error; the row may have been absorbed elsewhere).
+"""
+
+from __future__ import annotations
+
+import fcntl
+import json
+import os
+import sys
+
+
+def store_path() -> str:
+    state_dir = os.environ.get("S4L_STATE_DIR") or os.path.join(
+        os.path.expanduser("~"), ".social-autoposter-mcp"
+    )
+    return os.path.join(state_dir, "review-queue.json")
+
+
+def _match_rows(cands: list, patch: dict) -> list:
+    cid = patch.get("candidate_id")
+    if cid is not None:
+        rows = [c for c in cands if c.get("candidate_id") == cid]
+        if rows:
+            return rows
+    n = patch.get("n")
+    if isinstance(n, int) and 1 <= n <= len(cands):
+        return [cands[n - 1]]
+    return []
+
+
+def apply_patches(data: dict, patches: list) -> int:
+    cands = data.get("candidates") or []
+    patched = 0
+    for p in patches:
+        for c in _match_rows(cands, p):
+            sets = dict(p.get("set") or {})
+            if c.get("posted") is True:
+                sets.pop("terminal", None)
+                sets.pop("terminal_reason", None)
+            for k, v in sets.items():
+                if k == "posted" and v is not True and c.get("posted") is True:
+                    continue  # posted is sticky
+                c[k] = v
+            for k in p.get("unset") or []:
+                if k == "posted":
+                    continue
+                c.pop(k, None)
+            patched += 1
+    return patched
+
+
+def main() -> int:
+    src = sys.argv[1] if len(sys.argv) > 1 else "-"
+    raw = sys.stdin.read() if src == "-" else open(src).read()
+    patches = (json.loads(raw) or {}).get("patches") or []
+    sp = store_path()
+    with open(sp + ".lock", "w") as lk:
+        fcntl.flock(lk, fcntl.LOCK_EX)
+        try:
+            try:
+                with open(sp) as f:
+                    data = json.load(f)
+            except Exception:
+                data = {"candidates": []}
+            patched = apply_patches(data, patches)
+            tmp = f"{sp}.tmp.{os.getpid()}"
+            with open(tmp, "w") as f:
+                json.dump(data, f, indent=2)
+            os.replace(tmp, sp)
+        finally:
+            fcntl.flock(lk, fcntl.LOCK_UN)
+    print(json.dumps({"ok": True, "patched": patched}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())