@m13v/s4l 1.7.6-rc.24 → 1.7.6-rc.26

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.6-rc.24",
-  "installedAt": "2026-07-17T23:02:02.361Z"
+  "version": "1.7.6-rc.26",
+  "installedAt": "2026-07-17T23:10:55.248Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.6-rc.24",
+  "version": "1.7.6-rc.26",
   "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.6-rc.24",
+  "version": "1.7.6-rc.26",
   "private": true,
   "description": "Desktop MCP client for social-autoposter (X/Twitter rail): manual draft/review/approve loop, autopilot control, and stats. Thin wrapper over the existing pipeline scripts.",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l",
-  "version": "1.7.6-rc.24",
+  "version": "1.7.6-rc.26",
   "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

@@ -290,9 +290,10 @@ def build_prompt(project: dict, events: list[dict], overall_events: list[dict] |
             "before approving it, so every FINAL is a direct statement of the "
             "voice they want. The drafting model NO LONGER sees these pairs "
             "directly, so the ONLY way a rewrite's lesson reaches drafting is "
-            "if you distill it into a draft_style_notes entry. When 2+ examples "
-            "share a correction (a phrase type removed, a structure replaced, "
-            "tone or length shifted), write ONE draft_style_notes entry and "
+            "if you distill it into a draft_style_notes entry. Even a SINGLE "
+            "example with a clear correction (a phrase type removed, a "
+            "structure replaced, tone or length shifted) is enough to write a "
+            "draft_style_notes entry and "
             "embed a short before/after fragment as an anchor (e.g. rewrote "
             "'X' to 'Y') so the concrete rewrite travels with the rule. Ignore "
             "lead-specific or cosmetic edits (typo fixes, one-off facts); learn "
@@ -314,9 +315,9 @@ CURRENT content_guardrails.do_not: {json.dumps(guard_do_not)}{edit_examples_bloc
 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.
+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; even a single edit that shows a clear correction (a phrase type removed, a structure replaced, tone shifted, length cut) is enough to distill into draft_style_notes, and several agreeing only make it stronger. 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.
+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. A single pairwise choice is enough: diff the picked text against the not-picked one and distill WHAT differs (tone, structure, length, opener type, directness) into draft_style_notes, and several agreeing only make it stronger; 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.
 
@@ -324,7 +325,7 @@ You can also block SPECIFIC authors via the plan's block_authors list. A block i
 
 Propose changes to the block. RULES, in priority order:
 1. Be conservative. Prefer NO changes over speculative ones. An empty plan is a good plan when the evidence is thin.
-2. Generalize only what the evidence supports: 2+ events agreeing justify a general entry; a single reject justifies at most one narrowly-scoped entry, and only when its note, interactions, or author context (follower count, their post, discovery topic) makes the reason explicit. Exceptions: a single loved approval can justify one audience_prefer/thread entry when the pattern it shows is clear, and OVERALL FEEDBACK lines are explicit user instructions that outrank inferred signals; reflect each one in the most fitting list even from a single line, rewritten as a standing preference.
+2. A SINGLE reasoned event is enough to justify an entry; you do NOT need multiple events agreeing. When a reject carries a category, a note, a profile-click, or clear author/thread context, or an approval is loved, or the user edited the draft, or they made an explicit two-draft choice, distill the lesson right away into the most fitting list, generalized to the TYPE (never an individual handle or a one-off fact). More events agreeing only make the pattern stronger; they are not a precondition. OVERALL FEEDBACK lines are explicit user instructions that outrank inferred signals; reflect each one even from a single line, rewritten as a standing preference. The one exception is no_reason_given rejects, which stay weak (see below), because there the WHY is unknown, not because the count is low.
 3. Describe author/audience TYPES, never individual handles. "crypto/web3-native accounts shilling tokens" is right; "@someguy" is wrong. Preferences must generalize.
 4. Approvals are counter-evidence. If approvals contradict an existing entry, propose removing or narrowing it. Also propose removing entries that events show are stale.
 5. bad_draft events feed draft_style_notes (or, ONLY for a clearly recurring phrasing complaint, voice_never_add / guardrails_do_not_add; use those sparingly, they touch curated fields).

package/scripts/post_github.py

@@ -710,6 +710,14 @@ def parse_claude_json(output):
 # ---------- Posting + logging ------------------------------------------------
 
 def post_comment(owner, repo, number, body):
+    # Identity gate (mirrors twitter_browser.reply_to_tweet /
+    # reddit_browser.post_comment): the gh CLI would happily post as whatever
+    # account it is authed as, but with no resolved accounts.github.username
+    # the row's attribution is blank and self-filtering breaks. Refuse loudly.
+    from account_resolver import resolve as _resolve_gh
+    if not _resolve_gh("github"):
+        return False, ("no_account_configured (set accounts.github.username in "
+                       "config.json or AUTOPOSTER_GITHUB_USERNAME)")
     try:
         out = subprocess.check_output(
             ["gh", "issue", "comment", str(number), "-R", f"{owner}/{repo}", "--body", body],

package/scripts/reddit_browser.py

@@ -536,6 +536,15 @@ def post_comment(thread_url, text):
 
     Returns: {"ok": true, "permalink": "..."} or {"ok": false, "error": "..."}
     """
+    # Identity gate (mirrors twitter_browser.reply_to_tweet): refuse to post
+    # when no Reddit account resolves. Without it we cannot attribute the
+    # comment or find our own permalink afterwards, and posting with a blank
+    # identity pollutes the shared DB. Fail fast and loud instead.
+    if not OUR_USERNAME:
+        print("[reddit_browser] no reddit account configured "
+              "(accounts.reddit.username / reddit_account.username / "
+              "AUTOPOSTER_REDDIT_USERNAME); refusing to post.", file=sys.stderr)
+        return {"ok": False, "error": "no_account_configured"}
     from playwright.sync_api import sync_playwright
 
     with sync_playwright() as p:
@@ -837,6 +846,13 @@ def reply_to_comment(comment_permalink, text, dm_id=None):
     Returns: {"ok": true, "applied_campaigns": [...], "reply_text": "..."}
               or {"ok": false, "error": "..."}
     """
+    # Identity gate (mirrors twitter_browser.reply_to_tweet): no resolved
+    # account -> no post. See post_comment above for the rationale.
+    if not OUR_USERNAME:
+        print("[reddit_browser] no reddit account configured "
+              "(accounts.reddit.username / reddit_account.username / "
+              "AUTOPOSTER_REDDIT_USERNAME); refusing to post.", file=sys.stderr)
+        return {"ok": False, "error": "no_account_configured"}
     from playwright.sync_api import sync_playwright
 
     # Pre-flight: refuse to attempt a reply in a sub we know we can't comment in.

package/scripts/release-mcpb.sh

@@ -204,6 +204,15 @@ say "Regression gate: scripts/test_no_silent_fallbacks.py"
 python3 "$REPO_ROOT/scripts/test_no_silent_fallbacks.py" \
   || die "regression gate failed -- a silent-fallback / bare-python3 issue was (re)introduced. See output above; do not release until it's clean or the finding is reviewed into the test's ALLOWLIST with a reason."
 
+# Cross-language lockstep gate: candidate_state (s4l_state.py vs index.ts) and
+# the short-link fallback host constant (dm_short_links.py vs bin/server.js)
+# are duplicated across runtimes BY NECESSITY; this test is what turns their
+# "keep in lockstep" comments into an enforced invariant. Divergence here has
+# shipped real incidents (post_failed drain asymmetry 2026-07-17).
+say "Regression gate: scripts/test_cross_language_parity.py"
+python3 "$REPO_ROOT/scripts/test_cross_language_parity.py" \
+  || die "cross-language parity gate failed -- a TS/Python lockstep pair diverged (candidate_state or fallback host). Fix BOTH sides before releasing."
+
 # ---- 1. Resolve + WRITE version into the repo-root package.json -------------
 # The repo-root package.json is the SINGLE source of truth: `npm pack` reads it
 # to build the embedded pipeline.tgz, so the bundle shell and the bundled

package/scripts/score_twitter_candidates.py

@@ -538,8 +538,10 @@ def upsert_candidates(tweets, config, batch_id=None, attempts_map=None, scored_s
             # composite unique gives each account its own candidate row.
             # Without this, account A's 'posted' status on tweet X would lock
             # account B out of the same tweet (ON CONFLICT preserved 'posted').
-            # Defaults server-side to 'm13v_' if omitted; new callers should
-            # always pass it explicitly.
+            # If omitted, the server stamps a per-install 'unknown:<install_id>'
+            # sentinel (2026-07-18; it used to default to 'm13v_', silently
+            # impersonating the repo owner). Callers should always pass it —
+            # _resolve_twitter_handle() covers env -> config -> cookie mirror.
             "our_account": _twitter_handle or "",
             # Repost provenance (2026-06-04). The scan derives the author from
             # the status URL, so author_handle/tweet_url already point at the

package/scripts/test_cross_language_parity.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""Cross-language parity gate: constants and state machines that exist in BOTH
+the Python pipeline and the Node/TS MCP server MUST agree. Each pair here has a
+"keep in lockstep" comment at both definition sites; this test is what makes
+that comment enforceable instead of aspirational. Runs in the release gate
+(scripts/release-mcpb.sh) right after test_no_silent_fallbacks.py.
+
+Checks:
+  1. candidate_state parity — mcp/menubar/s4l_state.py::candidate_state (the
+     Python authority) vs mcp/src/index.ts::candidateState (the TS mirror),
+     evaluated with node on a fixture matrix covering every flag combination
+     and truthiness edge case. Divergence between hand-rolled raw-flag filters
+     and the state machine has produced real incidents (post_failed drain
+     asymmetry 2026-07-17, get_stats lane blindness); this pins the two
+     implementations to each other.
+  2. Short-link fallback host parity — scripts/dm_short_links.py
+     DEFAULT_FALLBACK_HOST vs bin/server.js SHORT_LINK_FALLBACK_HOST (CLAUDE.md:
+     "keep them in sync").
+
+Zero third-party deps. Needs `node` on PATH (the release script already does).
+Exit 0 = all pass; exit 1 with a FAIL line = parity broken, do not release.
+"""
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+FAILURES = []
+
+
+def report(ok, label, detail=""):
+    tag = "PASS" if ok else "FAIL"
+    line = f"{tag}  {label}"
+    if detail:
+        line += f"  -- {detail}"
+    print(line)
+    if not ok:
+        FAILURES.append(label)
+
+
+# ---------------------------------------------------------------------------
+# 1. candidate_state parity
+# ---------------------------------------------------------------------------
+
+# Every flag combination that matters, plus truthiness edge cases: Python uses
+# `is True` for posted/terminal/approved but bare truthiness for post_failed;
+# TS uses `=== true` and bare truthiness respectively. The matrix locks in that
+# BOTH implementations make the same call on non-boolean junk values too.
+FIXTURES = [
+    {},
+    {"approved": True},
+    {"approved": True, "post_failed": True},
+    {"post_failed": True},
+    {"post_failed": "posted_0"},
+    {"post_failed": ""},
+    {"post_failed": 0},
+    {"terminal": True},
+    {"terminal": True, "approved": True},
+    {"terminal": True, "post_failed": True, "approved": True},
+    {"posted": True},
+    {"posted": True, "approved": True},
+    {"posted": True, "terminal": True, "post_failed": True, "approved": True},
+    {"posted": False, "terminal": False, "approved": False},
+    {"posted": "yes"},
+    {"approved": 1},
+    {"terminal": 1, "approved": True},
+    {"posted": 1, "terminal": True},
+]
+
+
+def python_states():
+    sys.path.insert(0, os.path.join(REPO_ROOT, "mcp", "menubar"))
+    from s4l_state import candidate_state  # noqa: E402
+    return [candidate_state(dict(c)) for c in FIXTURES]
+
+
+def extract_ts_function():
+    """Pull the candidateState function body out of mcp/src/index.ts and strip
+    the TS type annotations so plain node can evaluate it. Brittle on purpose:
+    if the signature changes shape, this test fails loudly and must be updated
+    alongside it -- which is exactly the review moment the lockstep needs."""
+    src_path = os.path.join(REPO_ROOT, "mcp", "src", "index.ts")
+    with open(src_path, encoding="utf-8") as f:
+        src = f.read()
+    m = re.search(r"function candidateState\(c: PlanCandidate\): CandidateState \{", src)
+    if not m:
+        return None
+    start = m.start()
+    depth = 0
+    for i in range(m.end() - 1, len(src)):
+        if src[i] == "{":
+            depth += 1
+        elif src[i] == "}":
+            depth -= 1
+            if depth == 0:
+                body = src[start : i + 1]
+                return body.replace(
+                    "function candidateState(c: PlanCandidate): CandidateState {",
+                    "function candidateState(c) {",
+                )
+    return None
+
+
+def ts_states(fn_src):
+    node = shutil.which("node") or "/opt/homebrew/bin/node"
+    script = (
+        fn_src
+        + "\nconst fixtures = JSON.parse(require('fs').readFileSync(0, 'utf-8'));"
+        + "\nprocess.stdout.write(JSON.stringify(fixtures.map((c) => candidateState(c))));"
+    )
+    out = subprocess.run(
+        [node, "-e", script],
+        input=json.dumps(FIXTURES),
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    if out.returncode != 0:
+        raise RuntimeError(f"node evaluation failed: {out.stderr.strip()[:300]}")
+    return json.loads(out.stdout)
+
+
+def check_candidate_state():
+    fn_src = extract_ts_function()
+    if fn_src is None:
+        report(False, "candidateState() found in mcp/src/index.ts",
+               "signature changed? update extract_ts_function() alongside it")
+        return
+    try:
+        ts = ts_states(fn_src)
+    except Exception as e:
+        report(False, "candidateState() evaluates under node", str(e)[:200])
+        return
+    py = python_states()
+    for c, p, t in zip(FIXTURES, py, ts):
+        report(p == t, f"candidate_state parity for {json.dumps(c)}",
+               f"py={p} ts={t}")
+
+
+# ---------------------------------------------------------------------------
+# 2. short-link fallback host parity
+# ---------------------------------------------------------------------------
+
+def check_fallback_host():
+    py_path = os.path.join(REPO_ROOT, "scripts", "dm_short_links.py")
+    js_path = os.path.join(REPO_ROOT, "bin", "server.js")
+    py_m = js_m = None
+    try:
+        with open(py_path, encoding="utf-8") as f:
+            py_m = re.search(r"^DEFAULT_FALLBACK_HOST\s*=\s*['\"]([^'\"]+)['\"]",
+                             f.read(), re.M)
+        with open(js_path, encoding="utf-8") as f:
+            js_m = re.search(r"^const SHORT_LINK_FALLBACK_HOST\s*=\s*['\"]([^'\"]+)['\"]",
+                             f.read(), re.M)
+    except OSError as e:
+        report(False, "fallback-host files readable", str(e))
+        return
+    if not py_m or not js_m:
+        report(False, "fallback-host constants found",
+               f"py={'ok' if py_m else 'MISSING'} js={'ok' if js_m else 'MISSING'}")
+        return
+    report(py_m.group(1) == js_m.group(1),
+           "DEFAULT_FALLBACK_HOST (py) == SHORT_LINK_FALLBACK_HOST (js)",
+           f"py={py_m.group(1)} js={js_m.group(1)}")
+
+
+def main():
+    print("-- check 1: candidate_state TS/Python parity --")
+    check_candidate_state()
+    print("-- check 2: short-link fallback host parity --")
+    check_fallback_host()
+    print()
+    if FAILURES:
+        print(f"{len(FAILURES)} FAILURE(S)")
+        return 1
+    print("ALL PASS")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())