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

package/mcp/dist/index.js

@@ -1014,95 +1014,149 @@ async function postApproved(batchId, plan) {
     const approvedTwitter = approved.filter((c) => c.platform !== "reddit");
     let redditPosted = 0;
     let redditFailed = 0;
+    let redditSkippedPeerDrain = false;
     if (approvedReddit.length) {
-        for (const c of approvedReddit) {
-            const cc = c;
-            const dec = cc.reddit_decision;
-            const meta = (cc.reddit_plan_meta || {});
-            if (!dec) {
-                c.terminal = true;
-                c.terminal_reason = "reddit_decision_missing";
-                redditFailed++;
-                continue;
-            }
-            // The card's reply_text is the CANONICAL text (post_drafts edits write
-            // there); the embedded decision still carries the draft-time original.
-            // Posting dec.text verbatim would silently discard a human edit.
-            const decPost = {
-                ...dec,
-                text: (typeof cc.reply_text === "string" && cc.reply_text.trim())
-                    ? cc.reply_text
-                    : dec.text,
-            };
-            if (cc.engagement_style)
-                decPost.engagement_style = cc.engagement_style;
-            const miniPlan = {
-                project_name: meta.project_name || cc.matched_project,
-                batch_id: cc.reddit_batch_id || meta.batch_id || "reddit-mcp-approval",
-                phase: "draft",
-                decisions: [decPost],
-                style_assignment: meta.style_assignment || {},
-                generation_trace_path: meta.generation_trace_path,
-                session_id: meta.session_id || meta.draft_session_id,
-            };
-            const tmpPlan = path.join(process.env.S4L_TMP_DIR || "/tmp", `reddit_mcp_post_${Date.now()}_${Math.floor(Math.random() * 1e6)}.json`);
-            let r;
+        // Cross-instance drain gate (2026-07-14 drain storm): every one-shot MCP
+        // boot (the queue worker fires ~every minute; each boot runs the startup
+        // backlog drain) drained the SAME sticky approvals concurrently — 26
+        // drain plans in ~30 minutes, all fighting over the one reddit tab and
+        // false-positiving each other's posts. reddit-posting-active.json is the
+        // arbiter: post_reddit.py heartbeats it per row, and we stamp it around
+        // the whole drain here. A fresh flag (<120s) means a peer is mid-drain:
+        // leave the cards for it — approvals are sticky, nothing is lost.
+        const redditFlagPath = path.join(s4lStateDir(), "reddit-posting-active.json");
+        let redditPeerFresh = false;
+        try {
+            redditPeerFresh = Date.now() - fs.statSync(redditFlagPath).mtimeMs < 120_000;
+        }
+        catch {
+            redditPeerFresh = false;
+        }
+        const stampRedditFlag = () => {
             try {
-                fs.writeFileSync(tmpPlan, JSON.stringify(miniPlan));
-                r = await runPython("scripts/post_reddit.py", ["--phase", "post", "--in", tmpPlan], {
-                    timeoutMs: 900_000,
-                    env: {
-                        REDDIT_CDP_URL: process.env.REDDIT_CDP_URL || "http://127.0.0.1:9557",
-                        // Reviewed posts never get the active-campaign suffix (same rule
-                        // as the twitter manual-approval path below).
-                        S4L_SKIP_CAMPAIGN_SUFFIX: "1",
-                    },
-                    onLine: (line) => {
-                        const t = line.replace(/\s+$/, "");
-                        if (t.trim())
-                            console.error(`[post-reddit] ${t}`);
-                    },
-                });
+                fs.writeFileSync(redditFlagPath, JSON.stringify({ pid: process.pid, hb: Math.floor(Date.now() / 1000) }));
             }
-            catch (err) {
-                r = { code: -1, stdout: "", stderr: String(err) };
+            catch {
+                /* best effort */
+            }
+        };
+        if (redditPeerFresh) {
+            redditSkippedPeerDrain = true;
+            logPostEvent(`postApproved_reddit_skip batch=${batchId} reason=peer_drain_active cards=${approvedReddit.length}`);
+        }
+        else {
+            stampRedditFlag();
+            try {
+                for (const c of approvedReddit) {
+                    stampRedditFlag();
+                    const cc = c;
+                    const dec = cc.reddit_decision;
+                    const meta = (cc.reddit_plan_meta || {});
+                    if (!dec) {
+                        c.terminal = true;
+                        c.terminal_reason = "reddit_decision_missing";
+                        redditFailed++;
+                        continue;
+                    }
+                    // The card's reply_text is the CANONICAL text (post_drafts edits write
+                    // there); the embedded decision still carries the draft-time original.
+                    // Posting dec.text verbatim would silently discard a human edit.
+                    const decPost = {
+                        ...dec,
+                        text: (typeof cc.reply_text === "string" && cc.reply_text.trim())
+                            ? cc.reply_text
+                            : dec.text,
+                    };
+                    if (cc.engagement_style)
+                        decPost.engagement_style = cc.engagement_style;
+                    const miniPlan = {
+                        project_name: meta.project_name || cc.matched_project,
+                        batch_id: cc.reddit_batch_id || meta.batch_id || "reddit-mcp-approval",
+                        phase: "draft",
+                        decisions: [decPost],
+                        style_assignment: meta.style_assignment || {},
+                        generation_trace_path: meta.generation_trace_path,
+                        session_id: meta.session_id || meta.draft_session_id,
+                    };
+                    const tmpPlan = path.join(process.env.S4L_TMP_DIR || "/tmp", `reddit_mcp_post_${Date.now()}_${Math.floor(Math.random() * 1e6)}.json`);
+                    let r;
+                    try {
+                        fs.writeFileSync(tmpPlan, JSON.stringify(miniPlan));
+                        r = await runPython("scripts/post_reddit.py", ["--phase", "post", "--in", tmpPlan], {
+                            timeoutMs: 900_000,
+                            env: {
+                                REDDIT_CDP_URL: process.env.REDDIT_CDP_URL || "http://127.0.0.1:9557",
+                                // Reviewed posts never get the active-campaign suffix (same rule
+                                // as the twitter manual-approval path below).
+                                S4L_SKIP_CAMPAIGN_SUFFIX: "1",
+                            },
+                            onLine: (line) => {
+                                const t = line.replace(/\s+$/, "");
+                                if (t.trim())
+                                    console.error(`[post-reddit] ${t}`);
+                            },
+                        });
+                    }
+                    catch (err) {
+                        r = { code: -1, stdout: "", stderr: String(err) };
+                    }
+                    finally {
+                        try {
+                            fs.unlinkSync(tmpPlan);
+                        }
+                        catch {
+                            /* best effort */
+                        }
+                    }
+                    // post_reddit.py's summary marker: `[post_reddit] phase=post ... posted=N failed=M`
+                    const out = `${r.stdout}\n${r.stderr}`;
+                    const postedN = Number((/posted=(\d+)/.exec(out) || [])[1] || 0);
+                    if (r.code === 0 && postedN > 0) {
+                        c.posted = true;
+                        c.terminal = false;
+                        const urlMatch = /(https:\/\/(?:old\.|www\.)?reddit\.com\/r\/\S+)/.exec((/\[post_reddit\][^\n]*posted[^\n]*/i.exec(out) || [""])[0]);
+                        if (urlMatch)
+                            c.our_url = urlMatch[1];
+                        redditPosted++;
+                    }
+                    else {
+                        // Leave the approval sticky (approved && !posted && !terminal) so the
+                        // next post_drafts call retries, mirroring twitter's failed-drain
+                        // semantics; only stamp terminal on a conclusive CDP refusal.
+                        const cdpReason = (/\[post_reddit\] CDP FAILED: ([a-z_]+)/.exec(out) || [])[1];
+                        if (cdpReason && ["thread_locked", "thread_archived", "thread_not_found", "blocked_by_author"].includes(cdpReason)) {
+                            c.terminal = true;
+                            c.terminal_reason = `reddit_${cdpReason}`;
+                        }
+                        redditFailed++;
+                    }
+                }
             }
             finally {
+                // Clear only OUR stamp; a peer that took over mid-drain keeps its own.
                 try {
-                    fs.unlinkSync(tmpPlan);
+                    const cur = JSON.parse(fs.readFileSync(redditFlagPath, "utf-8"));
+                    if (cur && cur.pid === process.pid)
+                        fs.unlinkSync(redditFlagPath);
                 }
                 catch {
                     /* best effort */
                 }
             }
-            // post_reddit.py's summary marker: `[post_reddit] phase=post ... posted=N failed=M`
-            const out = `${r.stdout}\n${r.stderr}`;
-            const postedN = Number((/posted=(\d+)/.exec(out) || [])[1] || 0);
-            if (r.code === 0 && postedN > 0) {
-                c.posted = true;
-                c.terminal = false;
-                const urlMatch = /(https:\/\/(?:old\.|www\.)?reddit\.com\/r\/\S+)/.exec((/\[post_reddit\][^\n]*posted[^\n]*/i.exec(out) || [""])[0]);
-                if (urlMatch)
-                    c.our_url = urlMatch[1];
-                redditPosted++;
-            }
-            else {
-                // Leave the approval sticky (approved && !posted && !terminal) so the
-                // next post_drafts call retries, mirroring twitter's failed-drain
-                // semantics; only stamp terminal on a conclusive CDP refusal.
-                const cdpReason = (/\[post_reddit\] CDP FAILED: ([a-z_]+)/.exec(out) || [])[1];
-                if (cdpReason && ["thread_locked", "thread_archived", "thread_not_found", "blocked_by_author"].includes(cdpReason)) {
-                    c.terminal = true;
-                    c.terminal_reason = `reddit_${cdpReason}`;
-                }
-                redditFailed++;
-            }
+            logPostEvent(`postApproved_reddit batch=${batchId} attempted=${approvedReddit.length} posted=${redditPosted} failed=${redditFailed}`);
         }
-        logPostEvent(`postApproved_reddit batch=${batchId} attempted=${approvedReddit.length} posted=${redditPosted} failed=${redditFailed}`);
     }
     if (approvedTwitter.length === 0) {
         // All-reddit batch: persist the stamps and return without touching the
         // twitter preflight/lock path.
+        if (redditSkippedPeerDrain) {
+            return {
+                attempted: 0,
+                posted: 0,
+                exit_code: 0,
+                summary: "reddit: skipped (peer drain active); cards stay approved for the next drain",
+            };
+        }
         if (approvedReddit.length)
             mergeApprovedStampsIntoStore(batchId, plan, approvedReddit);
         return {

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.5-rc.13",
-  "installedAt": "2026-07-15T01:32:54.676Z"
+  "version": "1.7.5-rc.15",
+  "installedAt": "2026-07-15T15:59:07.613Z"
 }

package/mcp/manifest.json

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

@@ -3148,17 +3148,19 @@ class S4LMenuBar(rumps.App):
         self._ship_review_event(batch, decision)
         if not decision.get("approved"):
             n = decision.get("n")
-            # Durable local record FIRST, mirroring approved_queue_add for approvals.
+            # Durable local record FIRST, mirroring the approve branch below.
             # review_drafts() consults this, so the rejected card is suppressed from
             # re-review IMMEDIATELY and even if the loopback is down when the
             # background plan-flag write below runs. Without this, a reject was a
             # fire-and-forget loopback call with a swallowed exception, so rejects
             # silently vanished and the card "came back" — unlike durable approvals.
+            # A failure here is captured (not silently swallowed) so a broken
+            # durable write is visible instead of looking identical to success.
             try:
                 st.store_stamp_decision(batch, decision)
                 self._session_decisions.append(dict(decision))
-            except Exception:
-                pass
+            except Exception as e:
+                _capture(e, phase="reject_stamp_decision")
 
             def _persist_reject():
                 try:
@@ -3173,8 +3175,15 @@ class S4LMenuBar(rumps.App):
         # restart resumes the drain instead of stranding it and re-presenting the
         # card. The in-memory _post_q below is just the fast path; this file is the
         # source of truth review_drafts() consults to avoid re-showing it.
-        st.store_stamp_decision(batch, decision)
-        self._session_decisions.append(dict(decision))
+        # Same try/except shape as the reject branch above (was previously
+        # unguarded here, an asymmetry with no intentional reason): a failure is
+        # captured, not silently swallowed, and the post still gets enqueued below
+        # either way — this write is a resume/dedup aid, not a gate on posting.
+        try:
+            st.store_stamp_decision(batch, decision)
+            self._session_decisions.append(dict(decision))
+        except Exception as e:
+            _capture(e, phase="approve_stamp_decision")
         with self._review_lock:
             self._posts_outstanding += 1
             self._posting_batch_total += 1

package/mcp/menubar/s4l_state.py

@@ -209,15 +209,6 @@ def runtime_ready() -> bool:
     return bool(py and os.path.exists(py))
 
 
-def _launchctl_list() -> str:
-    try:
-        return subprocess.run(
-            ["launchctl", "list"], capture_output=True, text=True, timeout=10
-        ).stdout
-    except Exception:
-        return ""
-
-
 def autopilot_loaded() -> bool:
     # Autopilot is now the Claude Desktop scheduled task, not the legacy launchd job.
     cfg = os.environ.get("CLAUDE_CONFIG_DIR") or os.path.join(str(Path.home()), ".claude")
@@ -456,23 +447,6 @@ def snapshot():
     return out
 
 
-def stats_7d():
-    """7-day post stats; loopback only (the DB read needs the owned runtime)."""
-    res = loopback_tool("get_stats", {"days": 7})
-    if not isinstance(res, dict):
-        return None
-    projects = res.get("projects")
-    proj = projects[0] if isinstance(projects, list) and projects else None
-    p = (proj or {}).get("posts")
-    if not p:
-        return None
-    return {
-        "posts": p.get("total", 0),
-        "views": p.get("views_period_total", p.get("views", 0)),
-        "replies": p.get("comments_period_total", p.get("comments", 0)),
-    }
-
-
 # set_autopilot() (the launchd toggle) was removed: the autopilot is now the Claude
 # Desktop scheduled task `social-autoposter-autopilot`, managed in the Scheduled tab,
 # so the menu bar no longer toggles a launchd job (it mirrors the dashboard instead).
@@ -1028,8 +1002,9 @@ def review_drafts(plan, batch="review-queue"):
     must never be re-presented for review (approved ones proceed to post).
 
     Also excludes cards with ANY durable decision (approved, edited, rejected, or a
-    decided-but-failed post) via review_settled_ns(). approve/reject/edit are now
-    IDENTICAL: each writes a durable local record the INSTANT the user clicks, so a
+    decided-but-failed post) via _ledger_items_for_plan() below. approve/reject/edit
+    each write a durable local record via store_stamp_decision() the INSTANT the
+    user clicks (see s4l_menubar.py::_on_card_decision), so a
     decided card never re-presents even if the loopback (Claude Desktop) is down
     when the decision's plan-flag write is attempted. The main plan's
     `approved`/`terminal`/`posted` flags are only stamped once the loopback write
@@ -1386,75 +1361,6 @@ def toggle_lane(lane):
     return write_flags(f["personal_brand"], f["promotion"])
 
 
-def toggle_mode():
-    """Legacy whole-mode flip (mutually exclusive). Kept for old callers."""
-    new = (
-        MODE_PROMOTION
-        if read_mode() == MODE_PERSONAL_BRAND
-        else MODE_PERSONAL_BRAND
-    )
-    return write_mode(new)
-
-
-def review_reject_add(batch, n, candidate_id=None):
-    """Record a REJECT the INSTANT the user clicks, mirroring approved_queue_add.
-    Reject and approve are now IDENTICAL: both write a durable local record before
-    any loopback call, so review_drafts() suppresses the card even if the loopback
-    (Claude Desktop) is down when the reject's plan `terminal` write is attempted.
-    Dedups on (batch, n) within the CURRENT plan generation (a stale item's n
-    refers to a dead plan and must not absorb this decision); a reject is FINAL
-    and overrides any earlier status."""
-    with _approved_lock:
-        gen = _plan_generation(batch)
-        d = read_approved_queue()
-        for it in d["items"]:
-            if it.get("batch") == batch and it.get("n") == n and not _stale_for_plan(it, gen):
-                if it.get("status") != "rejected":
-                    it.update(status="rejected", error=None, ts=time_iso())
-                    _write_approved_queue(d)
-                return
-        d["items"].append({
-            "batch": batch, "n": n, "candidate_id": candidate_id,
-            "text": "", "edited": False,
-            "drop_link": False, "candidate_url": "", "status": "rejected",
-            "error": None, "ts": time_iso(),
-        })
-        _write_approved_queue(d)
-
-
-def approved_queue_add(batch, n, text="", edited=False, candidate_url="", drop_link=False,
-                       candidate_id=None):
-    """Record an approval the INSTANT the user clicks, before any posting. Dedups
-    on (batch, n) within the CURRENT plan generation: re-approving a card that's
-    still queued/posting/posted is a no-op; a previously FAILED card is reset to
-    queued so it retries. A stale item (previous plan generation, same n) must
-    not absorb the approval or the fresh card would silently never post.
-
-    candidate_id is the durable identity of the decision (twitter_candidates
-    row); n is only meaningful within one plan generation.
-
-    drop_link carries the user's "I deleted the link while editing" intent so a
-    restart-resumed post honors it too (else the poster re-appends the link)."""
-    with _approved_lock:
-        gen = _plan_generation(batch)
-        d = read_approved_queue()
-        for it in d["items"]:
-            if it.get("batch") == batch and it.get("n") == n and not _stale_for_plan(it, gen):
-                if it.get("status") == "failed":
-                    it.update(status="queued", text=text, edited=bool(edited),
-                              drop_link=bool(drop_link), error=None, ts=time_iso())
-                    _write_approved_queue(d)
-                return
-        d["items"].append({
-            "batch": batch, "n": n, "candidate_id": candidate_id,
-            "text": text, "edited": bool(edited),
-            "drop_link": bool(drop_link),
-            "candidate_url": candidate_url, "status": "queued",
-            "error": None, "ts": time_iso(),
-        })
-        _write_approved_queue(d)
-
-
 def approved_queue_set_status(batch, n, status, error=None):
     with _approved_lock:
         d = read_approved_queue()
@@ -1474,29 +1380,6 @@ def approved_queue_pending():
             if it.get("status") in ("queued", "posting")]
 
 
-def approved_queue_active_ns(batch):
-    """Plan indices the user has already approved for this batch — review_drafts()
-    excludes these so an approved card is never re-shown. Covers queued/posting
-    (in flight) AND posted: relying on the plan's posted flag alone leaves a window
-    (and breaks if the plan is regenerated), so the durable queue excludes posted
-    cards independently. `failed` is intentionally NOT excluded, so a failed post
-    falls back to manual review rather than silently vanishing."""
-    gen = _plan_generation(batch)
-    return {it.get("n") for it in read_approved_queue()["items"]
-            if it.get("batch") == batch and it.get("status") in ("queued", "posting", "posted")
-            and not _stale_for_plan(it, gen)}
-
-
-def review_settled_ns(batch):
-    """Plan indices with ANY durable user DECISION for this batch — review_drafts()
-    excludes these so approve, edit, and reject behave IDENTICALLY: a decided card
-    never re-presents for review. Covers queued/posting/posted (approved, in flight
-    or landed), `rejected`, AND `failed` (a decided-but-failed post is surfaced via
-    the failure notification + dashboard, NOT by re-showing it as a fresh review
-    card — that re-show was the "I already decided these came back" bug)."""
-    return {it.get("n") for it in _ledger_items_for_plan(batch, _plan_generation(batch))}
-
-
 def post_drafts(batch_id, post=None, edits=None, reject=None, clear_link=None, timeout=900, activity_label=None):
     """Post / reject drafts via the loopback tool. `post` = 1-based numbers to post
     as-is; `edits` = [{n, text}] to rewrite then post; `reject` = numbers to mark

package/mcp/package.json

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