@m13v/s4l 1.7.3 → 1.7.4-rc.1

package/mcp/dist/index.js

@@ -1394,6 +1394,31 @@ async function seedSearchQueriesForProject(project, rawQueries) {
         return { note: ` (Search-query seeding skipped — ${e.message}.)`, queries };
     }
 }
+// After a project save, persist the profile scan's engagement-ranked top
+// replies into that project's voice.examples (and the persona_corpus.txt
+// exemplar section when the project is the persona). Every drafting prompt on
+// every platform already mirrors voice.examples, so this ONE write feeds them
+// all. scripts/voice_exemplars.py reads the last_profile_scan.json sidecar
+// scan_x_profile.py wrote and only quotes the user's own public replies
+// verbatim (mechanical ranking, no synthesis). Best-effort by design: no scan
+// yet, no usable replies, or hand-written voice.examples (exit 3, respected)
+// all return null and never block the save.
+async function applyScannedVoiceExamples(project) {
+    try {
+        const res = await runPython("scripts/voice_exemplars.py", ["apply", "--project", project], {
+            timeoutMs: 30_000,
+        });
+        const last = res.stdout.trim().split("\n").slice(-1)[0] || "";
+        const parsed = JSON.parse(last);
+        if (parsed.ok && parsed.voice_examples_written) {
+            return `Stored ${parsed.voice_examples_written} of their top-performing real replies (ranked by engagement, with the threads they answered) as voice.examples — every drafter now mirrors them.`;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 // ---- engagement_mode: choose personal-brand vs product (setup-time) --------
 // Part of onboarding: AFTER X connect + profile_scan, BEFORE product config, the
 // agent asks the user which mode they want and calls this. It persists the mode
@@ -1603,6 +1628,10 @@ tool("engagement_mode", {
         return textContent(`Mode saved as ${mode}, but provisioning the persona project failed: ${e?.message || e}. ` +
             `Retry engagement_mode action:'set'.`);
     }
+    // Persist the profile scan's top-performing real replies as the persona's
+    // voice.examples + the persona_corpus.txt exemplar section (best-effort;
+    // see applyScannedVoiceExamples).
+    const personaExemplarNote = await applyScannedVoiceExamples(personaName);
     // Seed the persona's topics into the DB universe the cycle reads (best-effort;
     // the cycle's own fail-loud path still reports if topics are missing).
     let personaTopicsSeeded = false;
@@ -1687,6 +1716,7 @@ tool("engagement_mode", {
         persona_topic_count: personaTopicCount,
         persona_query_count: personaQueryCount,
         persona_query_note: personaQueryNote || null,
+        persona_voice_examples: personaExemplarNote,
         kicker_installed: kickerInstall ? kickerInstall.ok : null,
         kicker_detail: kickerInstall ? kickerInstall.detail : null,
         onboarding: onboardingSnapshot(),
@@ -1966,12 +1996,17 @@ tool("project_config", {
             counts: scan.counts,
             posts: scan.posts,
             comments: scan.comments,
+            top_posts: scan.top_posts,
+            top_replies: scan.top_replies,
             grounding_instructions: scan.grounding_instructions,
             website_research_instructions: WEBSITE_RESEARCH_INSTRUCTIONS,
             onboarding: onboardingSnapshot(),
             next_step: "FOUR steps, in order. FIRST (VOICE, from this scan): read the bio, posts, and comments " +
                 "as GROUND TRUTH and, per grounding_instructions, extract their profession/identity, " +
-                "voice & vibe (tone, phrasing, casing, tics), 2-4 verbatim golden-rule example replies, " +
+                "voice & vibe (tone, phrasing, casing, tics), verbatim golden-rule example replies (the " +
+                "scan pre-ranks these by real engagement in top_replies/top_posts, with stats, parent " +
+                "tweets, and thread continuations; persist them into the project's voice.examples so " +
+                "every drafter mirrors them), " +
                 "a phrase bank + things they avoid, and their icp. The scan is BACKWARD-LOOKING (only what " +
                 "they already posted) so it is the source for VOICE, not the primary source for topics. " +
                 "SECOND (the DICTATION interview — this is where TOPICS + grounding corpus come from, do NOT " +
@@ -2084,6 +2119,13 @@ tool("project_config", {
             });
         }
         const result = applySetup(args);
+        // Persist the profile scan's engagement-ranked exemplars into this
+        // project's voice.examples (+ the persona corpus section when the target
+        // is the persona). Reads the last_profile_scan.json sidecar the scanner
+        // wrote; verbatim quotes of the user's own public replies, so no
+        // synthesis happens here. Best-effort: no scan yet or hand-written
+        // examples present (exit 3) are both fine, and never block the save.
+        const exemplarNote = await applyScannedVoiceExamples(result.project);
         if (result.persona) {
             // no-op on the onboarding ledger; readiness is reported below as usual.
         }
@@ -2181,6 +2223,7 @@ tool("project_config", {
             kicker_detail: kickerInstall ? kickerInstall.detail : null,
             fields_set: result.fields_set,
             fields_removed: result.fields_removed,
+            voice_examples: exemplarNote,
             config_path: configPath(),
             onboarding: onboardingSnapshot(),
             note: (result.persona
@@ -2197,7 +2240,8 @@ tool("project_config", {
                     : `Saved what you provided for '${result.project}'. Still need: ${result.missing_required.join(", ")}. ` +
                         `First derive those fields from existing context, profile_scan, and website research, then ` +
                         `call project_config again with name='${result.project}'. Ask only if a required field is genuinely unknowable.`) +
-                advancedNote,
+                advancedNote +
+                (exemplarNote ? ` ${exemplarNote}` : ""),
         });
     }
     catch (e) {
@@ -5266,6 +5310,28 @@ async function main() {
     void sendStateSnapshot("startup");
     const ss = setInterval(() => void sendStateSnapshot("interval"), 15 * 60_000);
     ss.unref();
+    // One-shot voice-exemplar catch-up for installs onboarded BEFORE the
+    // exemplar feature: if the persona has no voice.examples_scanned_at, rescan
+    // the connected X profile and store the top-performing replies as
+    // voice.examples + the persona_corpus.txt exemplar section. Additive only
+    // (regenerates just its own marked corpus section; respects hand-written
+    // examples) and self-limiting (marker file rate-limits scan attempts;
+    // BAIL-ON-BUSY on the twitter-browser lock, so it never contends with a
+    // running cycle — it just retries on a later boot). Delayed so boot-time
+    // work (runtime provision, kicker install) settles first.
+    const backfill = setTimeout(() => {
+        if (isPaused())
+            return;
+        void runPython("scripts/voice_exemplars.py", ["backfill"], { timeoutMs: 420_000 })
+            .then((r) => {
+            const last = r.stdout.trim().split("\n").slice(-1)[0] || "";
+            console.error(`[social-autoposter-mcp] voice-exemplars backfill: ${last}`);
+        })
+            .catch((e) => {
+            console.error("[social-autoposter-mcp] voice-exemplars backfill failed:", e?.message || e);
+        });
+    }, 3 * 60_000);
+    backfill.unref();
 }
 main().catch(async (err) => {
     console.error("[social-autoposter-mcp] fatal:", err);

package/mcp/dist/twitterAuth.js

@@ -60,8 +60,9 @@ export async function xScanProfile(opts) {
         args.push("--handle", opts.handle);
     args.push("--posts", String(opts?.posts ?? 20));
     args.push("--comments", String(opts?.comments ?? 50));
-    // The scan scrolls two timelines; give it room but keep it bounded.
-    const res = await runPython("scripts/scan_x_profile.py", args, { timeoutMs: 180_000 });
+    // The scan scrolls two timelines plus visits the top posts' permalinks for
+    // thread expansion; give it room but keep it bounded.
+    const res = await runPython("scripts/scan_x_profile.py", args, { timeoutMs: 240_000 });
     try {
         return JSON.parse(res.stdout.trim().split("\n").slice(-1).join("\n"));
     }

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.3",
-  "installedAt": "2026-07-10T18:26:15.755Z"
+  "version": "1.7.4-rc.1",
+  "installedAt": "2026-07-10T22:41:18.186Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.3",
+  "version": "1.7.4-rc.1",
   "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.3",
+  "version": "1.7.4-rc.1",
   "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.3",
+  "version": "1.7.4-rc.1",
   "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/build_persona.py

@@ -90,9 +90,14 @@ GROUNDING_INSTRUCTIONS = (
     "  description    2-3 sentences: who this person is as a builder/voice.\n"
     "  content_angle  one paragraph of concrete, first-hand experience the "
     "persona can speak from (real projects, real numbers, real pain).\n"
-    "  voice          {tone, never[]}: how they actually write (read their own "
-    "posts/replies in the x source). Keep the organic rules: first person, "
-    "specific, no links, no feature lists, no sales, no em dashes.\n"
+    "  voice          {tone, never[], examples[]}: how they actually write (read "
+    "their own posts/replies in the x source). Keep the organic rules: first "
+    "person, specific, no links, no feature lists, no sales, no em dashes. For "
+    "examples[], the x source pre-ranks their best real replies/posts by "
+    "engagement (top_replies / top_posts, each with stats, the parent tweet, and "
+    "thread continuations): keep up to 5 verbatim, or run "
+    "`voice_exemplars.py apply --scan <x-source.json>` after apply to write "
+    "voice.examples + the persona_corpus.txt exemplar section deterministically.\n"
     "  search_topics  ~15 topics they have genuine experience with.\n"
     "  content_corpus (OPTIONAL but STRONGLY encouraged) the RAW gathered "
     "corpus as one plain-text block: the persona's actual posts, replies, repo "

package/scripts/engagement_styles.py

@@ -1034,7 +1034,18 @@ def compute_target_distribution(platform, context="posting"):
 # mode="invent" and the prompt hands the model the top N as reference
 # material to derive a new style from.
 
-INVENT_RATE = 0.05  # ~1 in 20 posts forces a new-style invention
+# 2026-07-10: inline invention retired (rate 0). It ran inside the drafting
+# prep session with the top-performers leaderboard + winner exemplars in
+# context, so every "new" style was a renamed clone of the winning
+# agree-then-relocate move; combined with name-only dedup the registry hit
+# ~938 styles that were mostly one structure. Invention now lives in the
+# standalone scripts/invent_styles.py job (operator-only launchd
+# com.m13v.s4l-invent-styles: the registry is global across installs, so a
+# central daily run replaces per-post rolls). The invent-mode plumbing in
+# pickers/posters is kept intact: register_style() is what the standalone
+# job calls, and a nonzero rate here re-enables the inline path if ever
+# wanted.
+INVENT_RATE = 0.0  # retired inline roll (was 0.05, ~1 in 20 posts)
 CURATED_TOP_N = 5   # size of the invent-mode reference list (top 5 by score)
 
 # Fallback target comment length (chars) for any style that lacks an explicit

package/scripts/invent_styles.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""scripts/invent_styles.py — standalone daily engagement-style invention.
+
+Architectural split (2026-07-10, mirrors the 2026-05-28 invent_topics.py
+split): in-cycle style invention (the picker's 5% INVENT_RATE roll) is
+retired. It ran INSIDE the drafting prep session, with the top-performers
+leaderboard and winner exemplars in context, so every "new" style was a
+renamed variant of the currently-winning move (agree-then-relocate /
+concede-then-reverse). Combined with name-only dedup in register_style,
+the registry accumulated hundreds of semantic clones.
+
+This job runs OUTSIDE any drafting context, on the operator Mac only:
+
+  - The registry is GLOBAL across installs (every install reads every
+    style), so invention must NOT fan out per install the way topic
+    invention does. One central daily run is the correct scope; that is
+    the deliberate difference from invent_topics.py's per-install kicker.
+  - The prompt carries the existing style universe and explicitly forbids
+    the dominant structural family; the ask is a style from an
+    UNREPRESENTED family, not a riff on the champion.
+  - Post-hoc semantic dedup (token-Jaccard on description+example, plus a
+    reframe-family heuristic) rejects near-clones; a rejection re-prompts
+    with a grown avoid-list, at most DUPE_RETRIES times.
+  - Accepted styles are registered via engagement_styles.register_style
+    (kind='model_invented'), same as the retired inline path, so pickers
+    see them on their next tick with zero other wiring.
+
+Scheduling: launchd com.m13v.s4l-invent-styles (operator Mac, daily).
+Uses run_claude.sh with tag 'invent-styles'; the tag is NOT in
+claude_job.py TAG_TO_TYPE, so it runs the local `claude -p` lane and has
+no dependency on the Desktop queue worker.
+
+CLI:
+  python3 scripts/invent_styles.py                 # invent + register 1
+  python3 scripts/invent_styles.py --max-new 2
+  python3 scripts/invent_styles.py --dry-run       # propose, don't register
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+
+_REPO_DIR = os.path.expanduser("~/social-autoposter")
+sys.path.insert(0, os.path.join(_REPO_DIR, "scripts"))
+from engagement_styles import get_all_styles, register_style  # noqa: E402
+
+_RUN_CLAUDE_SH = os.path.join(_REPO_DIR, "scripts", "run_claude.sh")
+SCRIPT_TAG = "invent-styles"
+CALL_TIMEOUT_SEC = 420
+DUPE_RETRIES = 3
+SIMILARITY_THRESHOLD = 0.5  # Jaccard on description+example tokens
+
+# Heuristic markers of the saturated agree-then-relocate/reframe family.
+# A proposal whose description/example leans on these is a clone of the
+# dominant move no matter how novel its name is; reject like a dupe.
+_REFRAME_MARKERS = re.compile(
+    r"\b(reframe|relocat\w+|the real (work|question|problem|cost|part|win)"
+    r"|hidden (cost|part|work|meter)|easy (part|half)|hard(er)? (part|half)"
+    r"|was never (the|about)|nobody (mentions|talks about|tracks|measures)"
+    r"|isn.t the .{0,30}it.s|concede)\b",
+    re.I,
+)
+
+
+def _tokens(text):
+    return set(re.findall(r"[a-z0-9]+", (text or "").lower()))
+
+
+def _jaccard(a, b):
+    ta, tb = _tokens(a), _tokens(b)
+    if not ta or not tb:
+        return 0.0
+    return len(ta & tb) / len(ta | tb)
+
+
+def _style_text(entry):
+    return f"{entry.get('description') or ''} {entry.get('example') or ''}"
+
+
+def _find_near_dupe(proposal, universe):
+    """Return (reason, existing_name) when the proposal is a clone; else None."""
+    name = proposal["name"]
+    if name in universe:
+        return ("name_exists", name)
+    ptext = _style_text(proposal)
+    if _REFRAME_MARKERS.search(f"{proposal.get('description','')} {name}"):
+        return ("reframe_family", "(dominant agree-then-relocate family)")
+    best_name, best_sim = None, 0.0
+    for ename, entry in universe.items():
+        sim = _jaccard(ptext, _style_text(entry))
+        if sim > best_sim:
+            best_name, best_sim = ename, sim
+    if best_sim >= SIMILARITY_THRESHOLD:
+        return (f"jaccard={best_sim:.2f}", best_name)
+    return None
+
+
+def build_prompt(universe, avoid):
+    names = sorted(universe.keys())
+    # Detail only a bounded sample (prompt-size guard): the seeds plus the
+    # most recently registered rows carry enough signal about what already
+    # exists; the full NAME list covers the rest for the model's self-check.
+    detailed = []
+    for name in names:
+        e = universe[name]
+        if e.get("kind") == "seed" or len(detailed) < 40:
+            desc = " ".join((e.get("description") or "").split())[:180]
+            detailed.append(f"- {name}: {desc}")
+        if len(detailed) >= 60:
+            break
+    avoid_block = ""
+    if avoid:
+        avoid_block = (
+            "\nAlready proposed and REJECTED this run (do not resubmit or "
+            "paraphrase): " + ", ".join(avoid) + "\n"
+        )
+    return f"""You maintain the engagement-style registry for a social reply system. A style is a named rhetorical TEMPLATE (description + one example reply) that drafters follow when writing short replies on X/Twitter and Reddit.
+
+PROBLEM: the registry is saturated with ONE structural family: agree-then-relocate (concede the surface point, move the spotlight to the hidden/harder/unmeasured part, often "X is easy, Y is the real work" or "X was never the point, Y is"). Do NOT invent another member of that family, however disguised.
+
+EXISTING STYLE NAMES ({len(names)} total):
+{", ".join(names)}
+
+REPRESENTATIVE DETAILS (sample):
+{chr(10).join(detailed)}
+{avoid_block}
+TASK: invent exactly ONE genuinely new style from a structural family that is missing or rare above. Families worth mining (pick ONE, or another you identify): direct answer with zero framing; first-person confession of a specific failure; pure curious question with no thesis; dry understatement one-liner; enthusiastic cosign with one concrete addition; flat disagreement stated plainly without conceding anything first; a tiny numbered checklist; a vivid analogy that does NOT end in a lesson; deadpan humor riffing on the thread's wording.
+
+Rules:
+- The example must read like a real human reply (lowercase ok), 40-220 chars, NO links, NO product names.
+- The style must be usable across many products and threads, not thread-specific.
+- Your answer will be dedup-checked by token similarity against every existing style's description+example; if you cannot find a genuinely different move, return the saturation envelope instead of forcing a paraphrase.
+
+Answer with ONLY one JSON object, no prose, in one of these two shapes:
+{{"name": "snake_case_name", "description": "...", "example": "...", "why_existing_didnt_fit": "...", "target_chars": <int, the length the example is>}}
+{{"saturated": true, "reason": "..."}}"""
+
+
+def call_claude(prompt):
+    proc = subprocess.run(
+        ["bash", _RUN_CLAUDE_SH, SCRIPT_TAG, "-p", "--output-format", "json",
+         prompt],
+        text=True, capture_output=True, timeout=CALL_TIMEOUT_SEC,
+    )
+    if proc.returncode == 79:
+        raise SystemExit("[invent_styles] provider blocked (exit 79); skipping run")
+    if proc.returncode != 0:
+        raise SystemExit(
+            f"[invent_styles] run_claude.sh exited {proc.returncode}: "
+            f"{(proc.stderr or '')[:400]}")
+    try:
+        envelope = json.loads(proc.stdout)
+        text = envelope.get("result") or ""
+    except json.JSONDecodeError:
+        text = proc.stdout
+    return text
+
+
+def _extract_json(text):
+    """Pull the first parseable JSON object out of model output."""
+    text = (text or "").strip()
+    fence = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.S)
+    if fence:
+        text = fence.group(1)
+    start = text.find("{")
+    while start != -1:
+        for end in range(len(text), start, -1):
+            try:
+                obj = json.loads(text[start:end])
+                if isinstance(obj, dict):
+                    return obj
+            except json.JSONDecodeError:
+                continue
+        start = text.find("{", start + 1)
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Standalone style invention job")
+    parser.add_argument("--max-new", type=int, default=1,
+                        help="How many styles to invent this run (default 1)")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Propose and dedup-check but do not register")
+    args = parser.parse_args()
+
+    registered = 0
+    for slot in range(max(1, args.max_new)):
+        universe = get_all_styles()
+        avoid = []
+        accepted = None
+        for attempt in range(1 + DUPE_RETRIES):
+            raw = call_claude(build_prompt(universe, avoid))
+            obj = _extract_json(raw)
+            if not obj:
+                print(f"[invent_styles] slot={slot} attempt={attempt} "
+                      f"unparseable output: {raw[:200]!r}", file=sys.stderr)
+                continue
+            if obj.get("saturated"):
+                print(f"[invent_styles] slot={slot} model reports saturation: "
+                      f"{obj.get('reason', '')[:200]}", file=sys.stderr)
+                break
+            name = str(obj.get("name") or "").strip()
+            if not re.fullmatch(r"[a-z0-9_]{3,60}", name):
+                print(f"[invent_styles] slot={slot} bad name {name!r}; retrying",
+                      file=sys.stderr)
+                avoid.append(name or "(unnamed)")
+                continue
+            dupe = _find_near_dupe({**obj, "name": name}, universe)
+            if dupe:
+                reason, existing = dupe
+                print(f"[invent_styles] slot={slot} rejected {name!r}: {reason} "
+                      f"vs {existing}", file=sys.stderr)
+                avoid.append(name)
+                continue
+            accepted = {**obj, "name": name}
+            break
+        if not accepted:
+            continue
+        if args.dry_run:
+            print(json.dumps({"dry_run": True, **accepted}, indent=2))
+            continue
+        status, entry = register_style(
+            accepted["name"],
+            {
+                "description": accepted.get("description", ""),
+                "example": accepted.get("example", ""),
+                "why_existing_didnt_fit": accepted.get("why_existing_didnt_fit", ""),
+                "target_chars": accepted.get("target_chars"),
+            },
+            source_post={"platform": "invent_styles_job", "model": "invent_styles"},
+        )
+        print(f"[invent_styles] slot={slot} register status={status} "
+              f"name={accepted['name']}", file=sys.stderr)
+        if status == "new":
+            registered += 1
+            print(json.dumps({"registered": accepted["name"],
+                              "description": accepted.get("description", "")}))
+    print(f"[invent_styles] done: registered={registered}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/recent_self_posts.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""scripts/recent_self_posts.py — cross-cycle anti-repetition context.
+
+Prints a prompt block listing OUR most recent posted replies on a platform
+(across ALL projects), so a drafting session can see what this account
+already sounds like and deliberately diverge. This is the cross-cycle
+complement to author_history_block.py (which is per-author only): before
+2026-07-10 the model never saw its own recent output across threads and
+kept recycling the same openers and sentence skeletons cycle after cycle.
+
+The block is explicitly NEGATIVE context ("do not sound like these"), the
+opposite of the top_performers few-shots. Keep it that way: never add
+engagement numbers or any "this one did well" framing here, or the model
+will read it as examples to imitate.
+
+Wired into (one callsite):
+  - skill/run-twitter-cycle.sh  (Phase 2b-prep PREP_PROMPT)
+
+CLI:
+  python3 scripts/recent_self_posts.py --platform twitter --limit 20
+
+Stdout is a ready-to-inject prompt block; EMPTY stdout when there are no
+rows or on any failure (the cycle must never block on this context).
+Stderr carries diagnostics only.
+"""
+
+import argparse
+import os
+import sys
+
+REPO_DIR = os.path.expanduser("~/social-autoposter")
+sys.path.insert(0, os.path.join(REPO_DIR, "scripts"))
+from http_api import api_get  # noqa: E402
+
+# Truncation length per reply. Long enough to expose the opener + skeleton
+# (the parts the model must avoid repeating), short enough that 20 rows stay
+# a small fraction of the prompt.
+SNIPPET_CHARS = 220
+
+
+def _load_active_campaign_suffixes():
+    """Best-effort list of active campaign suffix literals to strip.
+
+    Same contract as author_history_block._load_active_campaign_suffixes:
+    the block must never teach the model to echo a campaign suffix (the
+    tool layer appends its own copy at post time). On failure returns [].
+    """
+    suffixes = []
+    try:
+        resp = api_get(
+            "/api/v1/campaigns",
+            query={"status": "active", "has_suffix": "true", "limit": 500},
+        )
+        rows = ((resp or {}).get("data") or {}).get("campaigns") or []
+        for r in rows:
+            s = (r.get("suffix") or "").strip()
+            if s and s not in suffixes:
+                suffixes.append(s)
+    except Exception as e:
+        print(f"[recent_self_posts] suffix load failed: {e!r}", file=sys.stderr)
+    return suffixes
+
+
+def _strip_suffixes(text, suffixes):
+    """Trailing-only, idempotent strip (mirrors author_history_block)."""
+    if not text or not suffixes:
+        return text
+    cleaned = text.rstrip()
+    changed = True
+    while changed:
+        changed = False
+        for sfx in suffixes:
+            if sfx and cleaned.endswith(sfx):
+                cleaned = cleaned[: -len(sfx)].rstrip()
+                changed = True
+    return cleaned
+
+
+def _snippet(text, suffixes):
+    """One-line, suffix-stripped, truncated rendering of a reply."""
+    t = _strip_suffixes((text or "").strip(), suffixes)
+    t = " ".join(t.split())  # collapse newlines/runs of whitespace
+    if len(t) > SNIPPET_CHARS:
+        t = t[: SNIPPET_CHARS - 1].rstrip() + "…"
+    return t
+
+
+def build_block(platform, limit):
+    """Return the prompt block string, or "" when nothing to show."""
+    resp = api_get(
+        "/api/v1/posts",
+        query={
+            "platform": platform,
+            "status": "active",
+            "order_by": "posted_at",
+            "order_dir": "desc",
+            "limit": str(limit),
+        },
+    )
+    rows = ((resp or {}).get("data") or {}).get("posts") or []
+    suffixes = _load_active_campaign_suffixes()
+    items = []
+    for r in rows:
+        snip = _snippet(r.get("our_content"), suffixes)
+        if not snip:
+            continue
+        date = str(r.get("posted_at") or "")[:10]
+        proj = r.get("project_name") or "(no project)"
+        items.append(f"{len(items) + 1}. [{date} | {proj}] {snip}")
+        if len(items) >= limit:
+            break
+    if not items:
+        return ""
+    header = (
+        "## YOUR RECENT REPLIES (cross-cycle anti-repetition; NEGATIVE examples)\n"
+        f"The {len(items)} most recent replies this account posted, all projects. "
+        "This is what you ALREADY sound like. It is NOT a list to imitate. "
+        "Hard rules for every draft this cycle:\n"
+        "- Do NOT reuse any opener below (the first 6-8 words' shape counts, "
+        "not just the exact words).\n"
+        "- Do NOT reuse their sentence skeletons, rhetorical moves, or pet "
+        "phrases (recurring words like 'actually', 'the real X', copula "
+        "reframes 'X is the Y').\n"
+        "- If a draft you are writing starts to echo any entry below, stop "
+        "and rewrite it from a different entry point.\n"
+    )
+    return header + "\n".join(items)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Render the cross-cycle recent-self-replies prompt block")
+    parser.add_argument("--platform", default="twitter")
+    parser.add_argument("--limit", type=int, default=20)
+    args = parser.parse_args()
+    try:
+        block = build_block(args.platform, max(1, min(args.limit, 50)))
+    except Exception as e:
+        print(f"[recent_self_posts] failed: {e!r}", file=sys.stderr)
+        block = ""
+    if block:
+        print(block)
+
+
+if __name__ == "__main__":
+    main()