@m13v/s4l 1.7.4-rc.13 → 1.7.4-rc.16

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.4-rc.13",
-  "installedAt": "2026-07-11T02:59:38.374Z"
+  "version": "1.7.4-rc.16",
+  "installedAt": "2026-07-11T18:28:11.012Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.4-rc.13",
+  "version": "1.7.4-rc.16",
   "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.4-rc.13",
+  "version": "1.7.4-rc.16",
   "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.4-rc.13",
+  "version": "1.7.4-rc.16",
   "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",
@@ -160,4 +160,4 @@
     "pg": "^8.20.0",
     "ws": "^8.0.0"
   }
-}
+}

package/scripts/active_experiments.py

@@ -55,15 +55,24 @@ DESCRIPTIONS = {
         ),
     },
     "draft_prompt": {
+        "treatment_v3": (
+            "style-as-form: the assigned style is the binding FORM (defining "
+            "move + per-style length + self-check), learned preferences apply "
+            "inside it; keeps the v2 skeleton ban"
+        ),
+        "control_v3": (
+            "plain draft directive, uniform length clamp, no structure ban"
+        ),
+        # v2 arms (skeleton-ban) retired 2026-07-10; v1 arms
+        # (decoupled-product-pivot) retired 2026-07-06; kept so any
+        # straggler card from an old plan still explains itself.
         "treatment_v2": (
-            "skeleton ban: forbids the concede-then-reverse "
+            "v2, retired: skeleton ban, forbids the concede-then-reverse "
             '"easy X / hard Y" structure and forces varied entry points'
         ),
         "control_v2": (
-            "current draft directive (style + product pivot), no structure ban"
+            "v2, retired: draft directive (style + product pivot), no structure ban"
         ),
-        # v1 arms (decoupled-product-pivot) retired 2026-07-06; kept so any
-        # straggler card from an old plan still explains itself.
         "treatment": "v1, retired: product pivot decoupled from the reply",
         "control": "v1, retired: original draft directive",
     },
@@ -113,8 +122,9 @@ def collect(env=None):
         if var.startswith(ENV_PREFIX) and (v or "").strip():
             out[var[len(ENV_PREFIX):].lower()] = v.strip()
     # 2026-07-06: the personal_brand persona directive is now ARM-AWARE in
-    # run-twitter-cycle.sh (treatment_v2 adds the concede-then-reverse skeleton ban,
-    # control_v2 does not), so the assigned draft_prompt arm DOES touch persona
+    # run-twitter-cycle.sh (treatment_v3 adds the skeleton ban + two-layer
+    # style/preferences contract, control_v3 does not), so the assigned
+    # draft_prompt arm DOES touch persona
     # drafts. Keep it stamped so the arm surfaces on persona cards and the per-arm
     # readout covers both lanes. (Previously dropped here because the persona
     # directive overrode both arms wholesale; that is no longer the case.)

package/scripts/engage_twitter_helper.py

@@ -144,6 +144,59 @@ def _render_media_block(media) -> str:
     )
 
 
+def _build_chain_block(row) -> str:
+    """Conversation chain reconstructed from replies.parent_reply_id linkage.
+
+    Walks ancestors bottom-up via GET /api/v1/replies/:id and renders the
+    chain root-first, each hop showing the inbound comment and (when we
+    responded) our reply. Empty string when the row has no parent linkage:
+    the root post itself already rides PENDING_DATA via the posts JOIN
+    (our_content / thread_title), so a chain block would add nothing.
+
+    Like counterparty_history_block, the block is self-titled and lands
+    inline in PENDING_DATA — no shell-side prompt change needed.
+    """
+    parent_id = row.get("parent_reply_id")
+    if not parent_id:
+        return ""
+    hops = []
+    seen = set()
+    cur = parent_id
+    for _ in range(10):
+        if not cur or cur in seen:
+            break
+        seen.add(cur)
+        try:
+            resp = api_get(f"/api/v1/replies/{cur}")
+        except Exception:
+            break
+        r = (resp.get("data") or {}).get("reply") or {}
+        if not r:
+            break
+        hops.append(r)
+        cur = r.get("parent_reply_id")
+    if not hops:
+        return ""
+
+    def _one_line(text):
+        return " ".join((text or "").split())
+
+    lines = [
+        "## Conversation chain (reconstructed from our DB; root first — "
+        "the row you are drafting for replies to the LAST message)"
+    ]
+    for r in reversed(hops):
+        lines.append(f"@{r.get('their_author') or '?'}: {_one_line(r.get('their_content'))}")
+        ours = _one_line(r.get("our_reply_content"))
+        if ours:
+            lines.append(f"  our reply: {ours}")
+    lines.append(
+        f"@{row.get('their_author') or '?'}: {_one_line(row.get('their_content'))}"
+        "   <- you are replying to this"
+    )
+    return "\n".join(lines)
+
+
 def cmd_pending_data(batch_size: int) -> int:
     try:
         from account_resolver import resolve as _resolve_account  # noqa: WPS433
@@ -173,38 +226,50 @@ def cmd_pending_data(batch_size: int) -> int:
     # top slot then and get enriched.
     ENRICH_TOP_N = 60
     history_blocks = [""] * len(rows)
+    chain_blocks = [""] * len(rows)
     try:
         from concurrent.futures import ThreadPoolExecutor
         from counterparty_history import get_counterparty_history_block
 
         def _enrich(r):
             author = r.get("their_author")
-            if not author:
-                return ""
+            history = ""
+            if author:
+                try:
+                    _disengage, history = get_counterparty_history_block(
+                        platform="x",
+                        author=author,
+                        current_post_id=r.get("post_id"),
+                        current_reply_id=r.get("id"),
+                    )
+                    history = history or ""
+                except Exception as e:
+                    print(
+                        f"[engage_twitter_helper] counterparty_history failed "
+                        f"for @{author}: {e}",
+                        file=sys.stderr,
+                    )
             try:
-                _disengage, block = get_counterparty_history_block(
-                    platform="x",
-                    author=author,
-                    current_post_id=r.get("post_id"),
-                    current_reply_id=r.get("id"),
-                )
-                return block or ""
+                chain = _build_chain_block(r)
             except Exception as e:
                 print(
-                    f"[engage_twitter_helper] counterparty_history failed "
-                    f"for @{author}: {e}",
+                    f"[engage_twitter_helper] chain block failed "
+                    f"for reply {r.get('id')}: {e}",
                     file=sys.stderr,
                 )
-                return ""
+                chain = ""
+            return (history, chain)
 
         top_rows = rows[:ENRICH_TOP_N]
         with ThreadPoolExecutor(max_workers=8) as ex:
-            for idx, block in enumerate(ex.map(_enrich, top_rows)):
-                history_blocks[idx] = block
+            for idx, (history, chain) in enumerate(ex.map(_enrich, top_rows)):
+                history_blocks[idx] = history
+                chain_blocks[idx] = chain
         non_empty = sum(1 for b in history_blocks if b)
+        chains_non_empty = sum(1 for b in chain_blocks if b)
         print(
-            f"[engage_twitter_helper] counterparty_history enriched "
-            f"{len(top_rows)}/{len(rows)} rows ({non_empty} with non-empty block)",
+            f"[engage_twitter_helper] enriched {len(top_rows)}/{len(rows)} rows "
+            f"(history={non_empty}, chain={chains_non_empty} non-empty)",
             file=sys.stderr,
         )
     except Exception as e:
@@ -215,7 +280,7 @@ def cmd_pending_data(batch_size: int) -> int:
         )
 
     out = []
-    for r, history_block in zip(rows, history_blocks):
+    for r, history_block, chain_block in zip(rows, history_blocks, chain_blocks):
         out.append({
             "id": r.get("id"),
             "platform": r.get("platform"),
@@ -231,6 +296,7 @@ def cmd_pending_data(batch_size: int) -> int:
             "is_our_original_post": int(r.get("is_our_original_post") or 0),
             "project_name": r.get("project_name"),
             "counterparty_history_block": history_block,
+            "conversation_chain_block": chain_block,
             "their_media_block": _render_media_block(r.get("their_media")),
         })
     # json_agg(...) returns null when the array is empty; engage-twitter.sh's

package/scripts/engagement_styles.py

@@ -1464,38 +1464,53 @@ def get_assigned_style_prompt(platform, assignment, context="posting"):
     lines = []
 
     if assignment["mode"] == "use":
-        lines.append(f"## Your assigned engagement style: **{assignment['style']}**")
-        lines.append("")
-        lines.append(
-            f"This style was selected by the picker (weighted by live "
-            f"click-driven performance across {platform}). Use it. Do not "
-            f"swap it for a different listed style."
-        )
-        lines.append("")
-        lines.append(f"Platform tone: {policy.get('note', '')}")
-        lines.append("")
-        lines.append(f"**{assignment['style']}**: {assignment.get('description', '')}")
-        if assignment.get("example"):
-            lines.append(f'  Example: "{assignment["example"]}"')
-        if assignment.get("note"):
-            lines.append(f"  Note: {assignment['note']}")
-        # LENGTH A/B CONCLUDED 2026-06-04: control won, so the prompt always
-        # uses the legacy generic length guidance. The treatment's per-style
-        # target prompt remains preserved only in the shipped experiment card.
-        #
-        # EXCEPTION (2026-07-11, Draft-B explore slot): exploration
-        # assignments (pick_exploration_style, marked by `source`) honor the
-        # style's own target_chars so the A/B pair diverges on the length
-        # axis too. The uniform clamp flattened every draft to the same
-        # 2-sentence shape (user: "the older drafts looked all very similar
-        # in terms of the length"). The 06-04 conclusion still governs the
-        # scored path, which never carries `source`.
-        _explore_tc = assignment.get("target_chars")
-        if (assignment.get("source") in ("human_derived", "model_invented")
-                and _explore_tc):
+        # Draft-prompt A/B v3 (style-as-form, 2026-07-10): the treatment_v3
+        # arm renders the style as the BINDING FORM of the draft (defining
+        # move + per-style length for EVERY assignment + end-of-block
+        # self-check + two-layer learned_preferences contract). The arm is
+        # read from the env HERE because this block is rendered inside the
+        # cycle process where run-twitter-cycle.sh assigns and exports
+        # S4L_DRAFT_PROMPT_VARIANT (stamp-at-source: that same process also
+        # stamps the arm onto every plan candidate via active_experiments).
+        # Downstream/post-time consumers never re-read this env. Unset or
+        # control_v3 (and every non-twitter caller, which never has the env)
+        # renders the legacy block below unchanged.
+        _dp_arm = (os.environ.get("S4L_DRAFT_PROMPT_VARIANT") or "").strip()
+        if _dp_arm == "treatment_v3":
+            _tc = assignment.get("target_chars") or DEFAULT_TARGET_CHARS
+            lines.append(
+                f"## Your assigned engagement style: **{assignment['style']}** "
+                "(this is the FORM of the draft, not a flavor hint)"
+            )
+            lines.append("")
+            lines.append(
+                f"This style was selected by the picker (weighted by live "
+                f"click-driven performance across {platform}). Use it. Do not "
+                f"swap it for a different listed style."
+            )
+            lines.append("")
+            lines.append(f"Platform tone: {policy.get('note', '')}")
+            lines.append("")
+            lines.append(f"**{assignment['style']}**: {assignment.get('description', '')}")
+            if assignment.get("example"):
+                lines.append(f'  Example: "{assignment["example"]}"')
+            if assignment.get("note"):
+                lines.append(f"  Note: {assignment['note']}")
+            lines.append("")
+            lines.append(
+                "Commit to the form BEFORE writing. From the description and "
+                "example above, identify the style's DEFINING MOVE (the one "
+                "thing a draft in this style must contain: a specific number, "
+                "a question, a flat disagreement, a confession, whatever the "
+                "description names) and build the reply around that move. The "
+                "test: with the topic removed, a reader should be able to "
+                "identify this style from the draft's shape alone. If your "
+                "draft would read the same under any other style name, it "
+                "does not conform; rewrite it."
+            )
             lines.append("")
             lines.append(
-                f"**LENGTH: aim for about {int(_explore_tc)} characters** "
+                f"**LENGTH: aim for about {int(_tc)} characters** "
                 "(this style's own winning length; within about 30% either "
                 "way is fine, never above 250). Let the target set the form: "
                 "a very short target means one clipped line, a long one can "
@@ -1503,14 +1518,72 @@ def get_assigned_style_prompt(platform, assignment, context="posting"):
                 "This applies to the comment text only; any link/CTA the "
                 "system appends afterward is separate."
             )
+            lines.append("")
+            lines.append(
+                "Learned user preferences (the learned_preferences block in "
+                "the project context) apply INSIDE this form: they control "
+                "voice, wording, and what to avoid; they do not replace the "
+                "style's structure or length. If a preference seems to "
+                "conflict with the style's defining move, keep the move and "
+                "satisfy the preference within it."
+            )
+            lines.append("")
+            lines.append(
+                "SELF-CHECK before returning: (1) does the draft contain the "
+                "style's defining move? (2) is the length within about 30% "
+                "of the target? If either fails, rewrite once."
+            )
         else:
+            lines.append(f"## Your assigned engagement style: **{assignment['style']}**")
             lines.append("")
             lines.append(
-                "**LENGTH: keep it tight.** One or two sentences, well under the "
-                "250-character Twitter limit. A short, sharp reply almost always "
-                "beats a paragraph. This applies to the comment text only; any "
-                "link/CTA the system appends afterward is separate."
+                f"This style was selected by the picker (weighted by live "
+                f"click-driven performance across {platform}). Use it. Do not "
+                f"swap it for a different listed style."
             )
+            lines.append("")
+            lines.append(f"Platform tone: {policy.get('note', '')}")
+            lines.append("")
+            lines.append(f"**{assignment['style']}**: {assignment.get('description', '')}")
+            if assignment.get("example"):
+                lines.append(f'  Example: "{assignment["example"]}"')
+            if assignment.get("note"):
+                lines.append(f"  Note: {assignment['note']}")
+            # LENGTH A/B CONCLUDED 2026-06-04: control won, so the prompt always
+            # uses the legacy generic length guidance. The treatment's per-style
+            # target prompt remains preserved only in the shipped experiment card.
+            #
+            # EXCEPTION (2026-07-11, Draft-B explore slot): exploration
+            # assignments (pick_exploration_style, marked by `source`) honor the
+            # style's own target_chars so the A/B pair diverges on the length
+            # axis too. The uniform clamp flattened every draft to the same
+            # 2-sentence shape (user: "the older drafts looked all very similar
+            # in terms of the length"). The 06-04 conclusion still governs the
+            # scored path, which never carries `source`.
+            #
+            # (The draft-prompt v3 treatment arm above supersedes this clamp
+            # for its cycles; this legacy branch IS the v3 control arm.)
+            _explore_tc = assignment.get("target_chars")
+            if (assignment.get("source") in ("human_derived", "model_invented")
+                    and _explore_tc):
+                lines.append("")
+                lines.append(
+                    f"**LENGTH: aim for about {int(_explore_tc)} characters** "
+                    "(this style's own winning length; within about 30% either "
+                    "way is fine, never above 250). Let the target set the form: "
+                    "a very short target means one clipped line, a long one can "
+                    "breathe. Do NOT default to the usual two-sentence shape. "
+                    "This applies to the comment text only; any link/CTA the "
+                    "system appends afterward is separate."
+                )
+            else:
+                lines.append("")
+                lines.append(
+                    "**LENGTH: keep it tight.** One or two sentences, well under the "
+                    "250-character Twitter limit. A short, sharp reply almost always "
+                    "beats a paragraph. This applies to the comment text only; any "
+                    "link/CTA the system appends afterward is separate."
+                )
         lines.append("")
         lines.append(
             'In your output JSON, set "engagement_style" to exactly '

package/scripts/enrich_reply_parents.py

@@ -87,11 +87,14 @@ def fetch_fxtwitter(handle, tweet_id):
 def walk_ancestors(handle, tweet_id, sleep_s):
     """Ancestor chain bottom-up: [(id, handle), ...] parent first, root last.
 
-    Returns (chain, terminal) where terminal is 'root' when the walk reached a
-    non-reply tweet, or 'cut' when a hop was deleted/protected/transient (the
-    chain up to that point is still usable, but root attribution is not).
+    Returns (focal, chain, terminal): focal is the fetched tweet object for
+    tweet_id itself (None when it is gone/unfetchable — needed for quote
+    linkage), terminal is 'root' when the walk reached a non-reply tweet,
+    'gone'/'transient' when a hop was deleted/protected/errored (the chain up
+    to that point is still usable, but root attribution is not), or 'hop_cap'.
     """
     chain = []
+    focal = None
     cur_handle, cur_id = handle, tweet_id
     for _ in range(MAX_HOPS):
         status, tweet = fetch_fxtwitter(cur_handle, cur_id)
@@ -99,14 +102,16 @@ def walk_ancestors(handle, tweet_id, sleep_s):
         if status != "ok":
             # 'gone' is terminal (deleted/protected); 'transient' must NOT be
             # remembered, the next run retries it.
-            return chain, status
+            return focal, chain, status
+        if focal is None:
+            focal = tweet
         parent_id = tweet.get("replying_to_status")
         parent_handle = tweet.get("replying_to") or ""
         if not parent_id:
-            return chain, "root"
+            return focal, chain, "root"
         chain.append((str(parent_id), parent_handle))
         cur_handle, cur_id = parent_handle, parent_id
-    return chain, "hop_cap"
+    return focal, chain, "hop_cap"
 
 
 def lookup_our_post(tweet_id):
@@ -126,6 +131,16 @@ def lookup_tracked_reply(tweet_id):
     return rows[0] if rows else None
 
 
+def lookup_our_posted_reply(tweet_id):
+    """Reply row where WE authored the tweet (our_reply_id / our_reply_url)."""
+    resp = api_get(
+        "/api/v1/replies",
+        query={"platform": "x", "our_reply_status_id": str(tweet_id), "limit": "1"},
+    )
+    rows = (resp.get("data") or {}).get("replies") or []
+    return rows[0] if rows else None
+
+
 def fetch_work(limit, our_account=None, ids=None, before_id=None):
     if ids:
         out = []
@@ -158,13 +173,12 @@ def enrich_row(row, state, sleep_s, dry_run):
     if state.get(tid):
         return "state_skip"
 
-    chain, terminal = walk_ancestors(handle, tid, sleep_s)
-    if not chain:
+    focal, chain, terminal = walk_ancestors(handle, tid, sleep_s)
+    if focal is None:
         if terminal == "transient":
             return "transient"  # retry next run, no state write
-        # Deleted/protected focal tweet, or a standalone mention (not a reply).
-        state[tid] = "gone" if terminal == "gone" else "not_a_reply"
-        return state[tid]
+        state[tid] = "gone"  # deleted/protected focal tweet
+        return "gone"
 
     patch = {}
     matched_post = None
@@ -178,24 +192,56 @@ def enrich_row(row, state, sleep_s, dry_run):
         if not row.get("project_name") and matched_post.get("project_name"):
             patch["project_name"] = matched_post["project_name"]
 
-    parent_id, _parent_handle = chain[0]
-    tracked = lookup_tracked_reply(parent_id)
-    if tracked and tracked["id"] != rid:
-        patch["parent_reply_id"] = tracked["id"]
-        patch["depth"] = (tracked.get("depth") or 1) + 1
+    if chain:
+        parent_id, _parent_handle = chain[0]
+        # Immediate parent: another inbound reply we track, or a reply WE
+        # posted (the dominant case: a fan replying to our engagement reply).
+        tracked = lookup_tracked_reply(parent_id)
+        if tracked and tracked["id"] != rid:
+            patch["parent_reply_id"] = tracked["id"]
+            patch["depth"] = (tracked.get("depth") or 1) + 1
+        else:
+            ours = lookup_our_posted_reply(parent_id)
+            if ours and ours["id"] != rid:
+                patch["parent_reply_id"] = ours["id"]
+                patch["depth"] = (ours.get("depth") or 1) + 1
+                if "post_id" not in patch and ours.get("post_id"):
+                    patch["post_id"] = ours["post_id"]
+                if not row.get("project_name") and not patch.get("project_name") \
+                        and ours.get("project_name"):
+                    patch["project_name"] = ours["project_name"]
+
+    # Quote linkage: a quote-tweet of our post (or of a reply we posted) is
+    # engagement on our content even when replying_to_status is empty.
+    quote_id = str(((focal.get("quote") or {}).get("id")) or "")
+    if quote_id and "post_id" not in patch:
+        qpost = lookup_our_post(quote_id)
+        if qpost:
+            patch["post_id"] = qpost["id"]
+            if not row.get("project_name") and not patch.get("project_name") \
+                    and qpost.get("project_name"):
+                patch["project_name"] = qpost["project_name"]
+        elif "parent_reply_id" not in patch:
+            qours = lookup_our_posted_reply(quote_id)
+            if qours and qours["id"] != rid:
+                patch["parent_reply_id"] = qours["id"]
+                patch["depth"] = (qours.get("depth") or 1) + 1
+                if qours.get("post_id"):
+                    patch["post_id"] = qours["post_id"]
 
     if terminal == "root":
-        root_handle = (chain[-1][1] or "").lstrip("@")
-        if root_handle and not row.get("thread_author_handle"):
+        root_handle = (chain[-1][1] if chain else (focal.get("author") or {}).get("screen_name") or "")
+        root_handle = (root_handle or "").lstrip("@")
+        if chain and root_handle and not row.get("thread_author_handle"):
             patch["thread_author_handle"] = root_handle
 
     if not patch:
         if terminal == "transient":
             return "transient"  # incomplete walk; retry next run
-        # Full chain walked, nothing of ours in it: a foreign thread. Remember
-        # so we don't rewalk it every run.
-        state[tid] = "no_link"
-        return "no_link"
+        # Chain walked to root / cut by a deleted ancestor / not a reply at
+        # all, and nothing of ours anywhere in it: remember permanently.
+        state[tid] = "no_link" if chain else "not_a_reply"
+        return state[tid]
 
     if dry_run:
         print(f"  [DRY] reply {rid}: {json.dumps(patch)}")

package/scripts/generate_daily_human_style.py

@@ -193,11 +193,23 @@ def build_prompt(platform, replies, reserved_names):
     lines.append("")
     lines.append(
         "These replies all WON the thread (top of the conversation by likes). "
-        "Find the shared pattern that makes them work — the rhetorical move, "
+        "Find the shared pattern that makes them work: the rhetorical move, "
         "the structural shape, the relationship to the OP. Most winners "
         "share ONE pattern; that pattern is your new engagement style."
     )
     lines.append("")
+    lines.append(
+        "PRESERVE THE STRUCTURAL FINGERPRINT. Do not smooth the pattern "
+        "into a generic one-liner ('add a thoughtful counterpoint'); keep "
+        "what the winning replies actually DO on the page: how the first "
+        "words enter (lowercase noun, a number, the question itself, a "
+        "quoted phrase), how many sentences and of what shape (one clipped "
+        "line, two short + one long, a fragment), where the punch sits, "
+        "and what the reply refuses to do (no greeting, no hedge, no "
+        "summary). The char counts shown per reply are part of the "
+        "fingerprint; notice where the winners cluster."
+    )
+    lines.append("")
     lines.append(
         "Ignore: replies that win because of follower count, fame, or "
         "non-repeatable luck. Focus on the structural move that we (a "
@@ -209,14 +221,15 @@ def build_prompt(platform, replies, reserved_names):
     )
     lines.append("")
     for i, r in enumerate(replies, 1):
+        content = r.get("reply_content") or ""
         lines.append(
             f"### #{i} (likes={r['likes']}, replies={r['replies_count']}, "
-            f"rt={r['retweets']})"
+            f"rt={r['retweets']}, chars={len(content.strip())})"
         )
         lines.append(f"Thread: {r['thread_url']}")
         handle = r.get("reply_author_handle") or "(unknown)"
         lines.append(f"Reply by @{handle}:")
-        lines.append(f"> {r['reply_content']}")
+        lines.append(f"> {content}")
         lines.append("")
 
     lines.append("## Schema (match exactly)")
@@ -230,7 +243,12 @@ def build_prompt(platform, replies, reserved_names):
     lines.append("```")
     lines.append("{")
     lines.append('  "name": "<snake_case_name>",')
-    lines.append('  "description": "<one to three sentences describing the style>",')
+    lines.append(
+        '  "description": "<one to three sentences carrying the structural '
+        "fingerprint: the DEFINING MOVE (the one thing every draft in this "
+        "style must contain), the OPENING (how the first words enter), and "
+        'the sentence shape>",'
+    )
     lines.append('  "example": "<one short OP + reply pair demonstrating the style>",')
     lines.append('  "best_in": {')
     lines.append(f'    "{platform}": ["<short context label>", ...],')
@@ -255,8 +273,11 @@ def build_prompt(platform, replies, reserved_names):
         "MOVE (e.g. `mirror_and_extend`, `flip_to_alt`, not `good_reply`)."
     )
     lines.append(
-        "3. The description should make the style copyable: a future model "
-        "reading just that one sentence should know what to write."
+        "3. The description must make the style copyable AS A FORM: a future "
+        "model reading only the description must know the defining move, how "
+        "to open, and what sentence shape to write. 'Add a sharp "
+        "counterpoint' fails this test; 'one clipped sentence, no greeting, "
+        "opens with the concrete number the OP left out' passes."
     )
     lines.append(
         "4. The example should be a realistic OP + reply pair, not lifted "
@@ -270,7 +291,10 @@ def build_prompt(platform, replies, reserved_names):
     lines.append(
         "6. NEVER propose a style about including a product, a URL, or a "
         "mechanism. Our link-tail layer handles that downstream. The style "
-        "is about the text BEFORE the link."
+        "is about the text BEFORE the link. The note MAY state in one "
+        "clause how a plain product mention would enter this style if ever "
+        "(e.g. 'product name fits as the concrete example slot; never in "
+        "the opening'), but no URLs or link mechanics."
     )
     return "\n".join(lines)
 

package/scripts/invent_styles.py

@@ -15,12 +15,26 @@ This job runs OUTSIDE any drafting context, on the operator Mac only:
     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.
+  - VERBALIZED SAMPLING (2026-07-10, arXiv 2510.01171): a single "invent
+    one style" ask reliably returns the modal answer (typicality bias from
+    preference training), which is why 653 of ~950 registered styles
+    cluster at 53-98 target_chars and one rhetorical family. Instead the
+    prompt asks for N_CANDIDATES candidate styles WITH a verbalized
+    typicality probability each, and selection takes the LOWEST-probability
+    candidate that survives dedup: we sample the tail of the distribution,
+    not the mode. This is the principled fix; the family blocklist below is
+    only a backstop.
+  - The existing registry is framed as OCCUPIED NICHES to stay out of
+    (quality-diversity framing, arXiv 2310.13032), NOT as reference
+    inspiration; showing top performers as exemplars is what anchored the
+    retired inline path to the champion family.
+  - target_chars DIVERSITY: the prompt shows live length-band occupancy
+    and requires candidates to spread across bands, biased to the
+    least-occupied ones, so invention stops minting 80-char styles.
   - 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.
+    reframe-family heuristic) rejects near-clones; when every candidate is
+    rejected we re-prompt 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.
@@ -52,6 +66,12 @@ SCRIPT_TAG = "invent-styles"
 CALL_TIMEOUT_SEC = 420
 DUPE_RETRIES = 3
 SIMILARITY_THRESHOLD = 0.5  # Jaccard on description+example tokens
+N_CANDIDATES = 5            # verbalized-sampling fan-out per call
+
+# Length bands for target_chars diversity. Occupancy is computed live from
+# the registry and shown in the prompt; candidates must spread across bands
+# and bias toward the least-occupied ones.
+LENGTH_BANDS = [(30, 60), (60, 100), (100, 150), (150, 200), (200, 250)]
 
 # Heuristic markers of the saturated agree-then-relocate/reframe family.
 # A proposal whose description/example leans on these is a clone of the
@@ -98,6 +118,23 @@ def _find_near_dupe(proposal, universe):
     return None
 
 
+def band_occupancy(universe):
+    """[(lo, hi, count), ...] for LENGTH_BANDS over the registry's
+    target_chars. The live histogram the prompt shows so candidates can
+    claim underrepresented bands."""
+    counts = [0] * len(LENGTH_BANDS)
+    for e in universe.values():
+        try:
+            tc = int(e.get("target_chars") or 0)
+        except (TypeError, ValueError):
+            continue
+        for i, (lo, hi) in enumerate(LENGTH_BANDS):
+            if lo <= tc < hi:
+                counts[i] += 1
+                break
+    return [(lo, hi, counts[i]) for i, (lo, hi) in enumerate(LENGTH_BANDS)]
+
+
 def build_prompt(universe, avoid):
     names = sorted(universe.keys())
     # Detail only a bounded sample (prompt-size guard): the seeds plus the
@@ -117,25 +154,42 @@ def build_prompt(universe, avoid):
             "\nAlready proposed and REJECTED this run (do not resubmit or "
             "paraphrase): " + ", ".join(avoid) + "\n"
         )
+    bands = band_occupancy(universe)
+    band_lines = "\n".join(
+        f"- {lo}-{hi} chars: {count} existing styles"
+        f"{'  <- UNDERREPRESENTED, prefer this band' if count == min(c for _, _, c in bands) else ''}"
+        for lo, hi, count in bands
+    )
     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.
+The registry below is OCCUPIED TERRITORY, not inspiration. Your job is to find empty niches: structural families and length bands that no existing style covers. Do not riff on what is already there.
+
+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 propose any member of that family, however disguised.
 
 EXISTING STYLE NAMES ({len(names)} total):
 {", ".join(names)}
 
-REPRESENTATIVE DETAILS (sample):
+REPRESENTATIVE DETAILS (occupied niches, sample):
 {chr(10).join(detailed)}
+
+LENGTH-BAND OCCUPANCY (live registry histogram of target_chars):
+{band_lines}
 {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.
+TASK (verbalized sampling): generate {N_CANDIDATES} CANDIDATE styles. For each, verbalize a `probability`: how likely this exact style would be as a language model's single first answer to "invent a new reply style" (0.0-1.0, honest, they need not sum to 1). Deliberately include tail candidates: at least 3 of the {N_CANDIDATES} must have probability under 0.10, meaning genuinely atypical moves a model would almost never produce first. We will programmatically select from the LOW-probability tail, so the obvious candidates are effectively discards; put your creativity into the tail.
+
+Diversity requirements across the {N_CANDIDATES} candidates:
+- Each from a DIFFERENT structural family. Families worth mining (or others 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.
+- Each in a DIFFERENT length band from the histogram above, biased toward the least-occupied bands. `target_chars` must be the actual length of your example, and the example must genuinely inhabit its band (a 200-char style is narrative, not a padded one-liner).
 
-Rules:
-- The example must read like a real human reply (lowercase ok), 40-220 chars, NO links, NO product names.
+Per-candidate rules:
+- `description` must state the style's DEFINING MOVE (the one thing every draft in this style must contain) and its OPENING (how the first words enter: e.g. lowercase noun, a number, the question itself). A future model reading only the description must know exactly what shape to write.
+- `note` states when to use / when not to, and how a product mention would enter this style if ever (one clause; the link/CTA layer is downstream, so no URLs or link mechanics).
+- The example must read like a real human reply (lowercase ok), 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.
+- Every candidate is dedup-checked by token similarity against every existing style's description+example; if you cannot field {N_CANDIDATES} genuinely different moves, return the saturation envelope instead of forcing paraphrases.
 
 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>}}
+{{"candidates": [{{"name": "snake_case_name", "description": "...", "example": "...", "note": "...", "why_existing_didnt_fit": "...", "target_chars": <int>, "probability": <float>}}, ...]}}
 {{"saturated": true, "reason": "..."}}"""
 
 
@@ -202,21 +256,43 @@ def main():
                 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)
+            candidates = obj.get("candidates")
+            if not isinstance(candidates, list) or not candidates:
+                print(f"[invent_styles] slot={slot} attempt={attempt} no "
+                      f"candidates array in output", file=sys.stderr)
                 continue
-            accepted = {**obj, "name": name}
-            break
+            # Verbalized-sampling selection: walk the tail first (ascending
+            # verbalized probability = least typical candidate first) and
+            # take the first that survives dedup. The modal candidates at
+            # the top of the distribution only get a chance if every tail
+            # candidate is a clone.
+            def _prob(c):
+                try:
+                    return float(c.get("probability"))
+                except (TypeError, ValueError):
+                    return 1.0  # unparseable prob sorts as maximally typical
+            for cand in sorted(candidates, key=_prob):
+                name = str(cand.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}; "
+                          f"skipping candidate", file=sys.stderr)
+                    avoid.append(name or "(unnamed)")
+                    continue
+                dupe = _find_near_dupe({**cand, "name": name}, universe)
+                if dupe:
+                    reason, existing = dupe
+                    print(f"[invent_styles] slot={slot} rejected {name!r} "
+                          f"(p={_prob(cand):.2f}): {reason} vs {existing}",
+                          file=sys.stderr)
+                    avoid.append(name)
+                    continue
+                accepted = {**cand, "name": name}
+                print(f"[invent_styles] slot={slot} selected tail candidate "
+                      f"{name!r} (p={_prob(cand):.2f}) from "
+                      f"{len(candidates)} candidates", file=sys.stderr)
+                break
+            if accepted:
+                break
         if not accepted:
             continue
         if args.dry_run:
@@ -227,6 +303,7 @@ def main():
             {
                 "description": accepted.get("description", ""),
                 "example": accepted.get("example", ""),
+                "note": accepted.get("note", ""),
                 "why_existing_didnt_fit": accepted.get("why_existing_didnt_fit", ""),
                 "target_chars": accepted.get("target_chars"),
             },

package/scripts/linkedin_cadence.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""LinkedIn posting cadence: 4 active days, then a mandatory 2-day break.
+
+Per user instruction (2026-07-11): LinkedIn activity should not run more than
+four days at a time before taking a two-day break. "Active day" is counted
+only when real posting/engagement activity actually happened that day (an
+outage day does not count toward the four), and the break pauses ALL LinkedIn
+traffic, including the passive presence-check job, not just posting.
+
+Every LinkedIn entrypoint (skill/run-linkedin.sh, engage-linkedin.sh,
+engage-dm-replies.sh, dm-outreach-linkedin.sh, audit-linkedin.sh,
+linkedin-presence.sh) already gates on the existence of ONE file:
+    ~/.claude/social-autoposter/linkedin.killswitch
+That file is scripts/linkedin_killswitch.py's antibot killswitch. This module
+reuses the SAME file for a scheduled break (signal="scheduled_break") so every
+entrypoint pauses automatically, with zero edits to the locked entrypoint
+scripts. It never overwrites a REAL antibot signal, and linkedin_killswitch.py
+is patched (recover-check) to never try to auto-recover a scheduled_break.
+
+State lives at ~/.claude/social-autoposter/linkedin_cadence.json:
+    {
+      "phase": "active" | "break",
+      "phase_started": "2026-07-11T20:00:00Z",
+      "active_days": ["2026-07-13", "2026-07-14", ...]   # UTC dates with
+                                                          # confirmed posts,
+                                                          # only meaningful
+                                                          # while phase=active
+    }
+
+CLI:
+    python3 scripts/linkedin_cadence.py enforce   # one tick; called every 15m
+    python3 scripts/linkedin_cadence.py status    # print state (json)
+"""
+
+import json
+import os
+import sys
+from datetime import datetime, timedelta, timezone
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import http_api  # noqa: E402
+import linkedin_killswitch as ks  # noqa: E402
+
+STATE_DIR = os.path.expanduser(
+    os.environ.get("LINKEDIN_KILLSWITCH_DIR", "~/.claude/social-autoposter")
+)
+STATE_FILE = os.path.expanduser(
+    os.environ.get("LINKEDIN_CADENCE_FILE", os.path.join(STATE_DIR, "linkedin_cadence.json"))
+)
+
+ACTIVE_DAYS_TARGET = int(os.environ.get("LINKEDIN_CADENCE_ACTIVE_DAYS", "4"))
+BREAK_DAYS = int(os.environ.get("LINKEDIN_CADENCE_BREAK_DAYS", "2"))
+
+SCHEDULED_BREAK_SIGNAL = "scheduled_break"
+
+
+def _now():
+    return datetime.now(timezone.utc)
+
+
+def _now_iso():
+    return _now().strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _today_str():
+    return _now().date().isoformat()
+
+
+def _parse_ts(ts):
+    return datetime.strptime(ts, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
+
+
+def _ensure_dir():
+    os.makedirs(STATE_DIR, exist_ok=True)
+
+
+def load_state():
+    try:
+        with open(STATE_FILE, "r") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def save_state(state):
+    _ensure_dir()
+    tmp = STATE_FILE + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(state, f, indent=2)
+        f.write("\n")
+    os.replace(tmp, STATE_FILE)
+
+
+def _default_state_starting_break():
+    # First-ever run: user asked to start immediately with a two-day break.
+    return {"phase": "break", "phase_started": _now_iso(), "active_days": []}
+
+
+def _today_post_count():
+    """LinkedIn posts made today (UTC), via the same API the dashboard uses.
+
+    Best-effort: returns None on any failure so callers can skip counting
+    this tick rather than wrongly recording 0 activity."""
+    try:
+        resp = http_api.api_get(
+            "/api/v1/dashboard/posts-per-day", {"days": 1, "platform": "linkedin"}
+        )
+        rows = (resp or {}).get("data", {}).get("rows", [])
+        today = _today_str()
+        for row in rows:
+            if row.get("day") == today:
+                return int(row.get("posts_made") or 0)
+        return 0
+    except Exception as exc:
+        print(f"[linkedin_cadence] WARN: posts-per-day query failed: {exc}", file=sys.stderr)
+        return None
+
+
+def _pause_marker_set():
+    """Set the shared killswitch file for a scheduled break, unless a REAL
+    antibot signal is already in charge (never stomp a genuine block)."""
+    payload = ks.read()
+    if payload is None:
+        ks.engage(
+            signal=SCHEDULED_BREAK_SIGNAL,
+            detail="cadence: scheduled 2-day pause after 4 active days",
+            send_email=False,
+        )
+        print("[linkedin_cadence] pause marker set (scheduled_break)", file=sys.stderr)
+    elif payload.get("signal") == SCHEDULED_BREAK_SIGNAL:
+        pass  # already set by us; idempotent, no trail spam
+    else:
+        print(
+            f"[linkedin_cadence] real killswitch already active (signal="
+            f"{payload.get('signal')!r}); deferring to it, not overwriting",
+            file=sys.stderr,
+        )
+
+
+def _pause_marker_clear_if_ours():
+    payload = ks.read()
+    if payload is not None and payload.get("signal") == SCHEDULED_BREAK_SIGNAL:
+        ks.clear()
+        print("[linkedin_cadence] pause marker cleared (break ended)", file=sys.stderr)
+
+
+def enforce():
+    state = load_state() or _default_state_starting_break()
+    if load_state() is None:
+        save_state(state)
+        print(
+            f"[linkedin_cadence] no prior state; starting BREAK phase now "
+            f"({BREAK_DAYS}d)",
+            file=sys.stderr,
+        )
+
+    now = _now()
+    phase = state["phase"]
+
+    if phase == "break":
+        started = _parse_ts(state["phase_started"])
+        elapsed = now - started
+        if elapsed >= timedelta(days=BREAK_DAYS):
+            state = {"phase": "active", "phase_started": _now_iso(), "active_days": []}
+            save_state(state)
+            _pause_marker_clear_if_ours()
+            print(
+                f"[linkedin_cadence] break ended after {elapsed}; switching to ACTIVE",
+                file=sys.stderr,
+            )
+            phase = "active"
+        else:
+            remaining = timedelta(days=BREAK_DAYS) - elapsed
+            _pause_marker_set()
+            print(
+                f"[linkedin_cadence] BREAK phase: {remaining} remaining",
+                file=sys.stderr,
+            )
+            return
+
+    # phase == "active"
+    real_block = ks.read()
+    if real_block is not None and real_block.get("signal") != SCHEDULED_BREAK_SIGNAL:
+        print(
+            f"[linkedin_cadence] account down for a real reason (signal="
+            f"{real_block.get('signal')!r}); not counting today, not pausing",
+            file=sys.stderr,
+        )
+        return
+
+    count = _today_post_count()
+    today = _today_str()
+    if count is not None and count > 0 and today not in state["active_days"]:
+        state["active_days"].append(today)
+        save_state(state)
+        print(
+            f"[linkedin_cadence] activity confirmed today ({count} posts); "
+            f"active_days={len(state['active_days'])}/{ACTIVE_DAYS_TARGET} "
+            f"{state['active_days']}",
+            file=sys.stderr,
+        )
+
+    if len(state["active_days"]) >= ACTIVE_DAYS_TARGET:
+        state = {"phase": "break", "phase_started": _now_iso(), "active_days": []}
+        save_state(state)
+        _pause_marker_set()
+        print(
+            f"[linkedin_cadence] {ACTIVE_DAYS_TARGET} active days reached; "
+            f"switching to BREAK for {BREAK_DAYS}d",
+            file=sys.stderr,
+        )
+    else:
+        print(
+            f"[linkedin_cadence] ACTIVE phase: "
+            f"{len(state['active_days'])}/{ACTIVE_DAYS_TARGET} active days so far",
+            file=sys.stderr,
+        )
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] not in ("enforce", "status"):
+        print("usage: linkedin_cadence.py [enforce|status]", file=sys.stderr)
+        sys.exit(2)
+    if sys.argv[1] == "status":
+        state = load_state()
+        print(json.dumps(state if state is not None else {"phase": None}, indent=2))
+        sys.exit(0)
+    enforce()
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/linkedin_killswitch.py

@@ -145,6 +145,10 @@ VALID_SIGNALS = {
     "session_invalid_marker",
     "captcha_detected",
     "manual",
+    # Deliberate pause from scripts/linkedin_cadence.py (4-active-days /
+    # 2-day-break schedule). Not an incident: recover-check must never try to
+    # auto-recover it, and engage() should never email on it.
+    "scheduled_break",
 }
 
 
@@ -894,6 +898,14 @@ def _cmd_recover_check(args):
     if not is_active():
         print("recover-check: killswitch not active, nothing to recover", file=sys.stderr)
         sys.exit(1)
+    payload = read() or {}
+    if payload.get("signal") == "scheduled_break":
+        print(
+            "recover-check: scheduled_break active (cadence pause, not a real "
+            "incident); deferring to scripts/linkedin_cadence.py, not probing",
+            file=sys.stderr,
+        )
+        sys.exit(1)
     if is_terminal():
         print(
             "recover-check: TERMINAL (auto-recovery gave up); "

package/skill/linkedin-cadence.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# linkedin-cadence.sh — enforce the 4-active-day / 2-day-break LinkedIn
+# posting schedule (user instruction, 2026-07-11). Fired every 15 minutes by
+# launchd (com.m13v.social-linkedin-cadence). All logic lives in
+# scripts/linkedin_cadence.py; this wrapper just logs the tick.
+
+set -uo pipefail
+export PATH="/opt/homebrew/bin:$PATH"
+
+REPO_DIR="$HOME/social-autoposter"
+LOG_DIR="$REPO_DIR/skill/logs"
+mkdir -p "$LOG_DIR"
+LOG="$LOG_DIR/linkedin-cadence.log"
+
+log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG" >&2; }
+
+PY="/opt/homebrew/bin/python3"
+[ -x "$PY" ] || PY="/usr/bin/python3"
+
+"$PY" "$REPO_DIR/scripts/linkedin_cadence.py" enforce >>"$LOG" 2>&1

package/skill/run-twitter-cycle.sh

@@ -1725,7 +1725,7 @@ log "Engagement style assigned: mode=$PICKED_MODE style=${PICKED_STYLE:-(invent)
 # are actually different (a same-name pair defeats the whole point); INVENT
 # mode on either side is accepted immediately since an invented name is
 # definitionally distinct from a pinned one. This is orthogonal to the
-# treatment_v2/control_v2 draft-prompt A/B below (that varies WORDING of the
+# treatment_v3/control_v3 draft-prompt A/B below (that varies WORDING of the
 # directive for the whole cycle; this varies STYLE per draft slot), so neither
 # experiment disturbs the other.
 STYLE_ASSIGN_FILE_B=$(mktemp -t s4l_twitter_assign_b_XXXXXX.json)
@@ -1793,38 +1793,44 @@ fi
 export S4L_EXP_DRAFT_B_SOURCE="$DRAFT_B_SOURCE"
 log "Engagement style B assigned: mode=$PICKED_MODE_B style=${PICKED_STYLE_B:-(invent)} source=$DRAFT_B_SOURCE"
 
-# --- Draft-prompt A/B: decouple product pivot (2026-06-29) -------------------
+# --- Draft-prompt A/B: style-as-form (v3, 2026-07-10) ------------------------
 # Per-CYCLE arm (the prep session drafts the whole batch from ONE prompt, so
 # assignment is at cycle granularity, not per post; the whole batch shares it).
-#   control   = the current draft directive verbatim.
-#   treatment = v2 (2026-07-06): bans the concede-then-reverse antithesis skeleton
-#               ('X is the easy part, the hard part is Y', "not X it's Y", etc.) in
-#               ANY form and forces varied entry points. v1 (2026-06-29) only
-#               forbade pivoting to the PRODUCT, which the model satisfied while
-#               keeping the skeleton (measured: treatment 30% ~= control 28% on
-#               857 local replies), so v2 bans the STRUCTURE, not just the product
-#               tail. The SAME skeleton ban is also added to the personal_brand
-#               directive below (which overrides both arms), so the persona lane
-#               (e.g. customer personal-brand accounts like Karol) gets it too.
-#               Product still mentioned only when genuinely relevant.
+#   control_v3   = the plain draft directive (v2's control text verbatim).
+#   treatment_v3 = style-as-FORM package: the assigned engagement style is the
+#                  binding FORM of the draft (defining move + per-style length +
+#                  end-of-block self-check, rendered arm-aware by
+#                  engagement_styles.get_assigned_style_prompt, which reads
+#                  S4L_DRAFT_PROMPT_VARIANT at render time IN this cycle
+#                  process), PLUS the two-layer learned_preferences contract
+#                  (style owns form, preferences own voice inside it; the old
+#                  'overrides on conflict' phrasing made the model treat the
+#                  style as optional), PLUS the v2 skeleton ban carried over.
+#   History: v1 (2026-06-29) decoupled the product pivot; the model kept the
+#   skeleton (30% ~= 28% on 857 replies). v2 (2026-07-06) banned the
+#   concede-then-reverse STRUCTURE. v3 (2026-07-10) replaces v2's treatment
+#   wholesale: drafts converged in shape regardless of assigned style, so v3
+#   makes the style block load-bearing instead of only banning one skeleton.
 # The arm is stamped onto every post this cycle via S4L_DRAFT_PROMPT_VARIANT
 # (read by twitter_post_plan.py -> log_post.py -> posts.draft_prompt_variant),
 # mirroring the tail_link_variant plumbing. Split tunable via
 # TWITTER_DRAFT_PROMPT_AB_RATE = fraction of cycles assigned to 'treatment'.
 # CODE DEFAULT 0.5 = 50/50 EVERYWHERE (2026-07-06): every install runs a real
-# holdback so treatment (skeleton-ban, v2) can always be measured against the old
-# control prompt. The old default of 1 (100% treatment) was changed because it
+# holdback so treatment can always be measured against the plain control
+# prompt. The old default of 1 (100% treatment) was changed because it
 # silently dropped the control arm whenever the .env pin did not propagate to the
 # running env (the installed-package driver reads its OWN .env, not the source
 # tree's), leaving no control data. Robustly defaulting to 0.5 in code, not via an
 # .env override, prevents that. The dashboard reads the SAME var with the SAME
 # default (bin/server.js), so display and routing never diverge.
 DRAFT_PROMPT_AB_RATE="${TWITTER_DRAFT_PROMPT_AB_RATE:-0.5}"
-# Arm VALUE versioned to '..._v2' on 2026-07-06 to RESET the experiment. The old
-# 'treatment'/'control' rows (v1, decoupled-product-pivot) are retired: they stay
-# in the DB under their old labels but the dashboard now counts only the '_v2'
-# arms, so the v2 skeleton-ban experiment starts fresh from zero. Bump this suffix
-# again on any future reset (keep bin/server.js DRAFT_PROMPT_VARIANT_DEFS in sync).
+# Arm VALUE versioned to '..._v3' on 2026-07-10 to RESET the experiment. The old
+# v1/v2 rows stay in the DB under their old labels but the dashboard now counts
+# only the '_v3' arms, so the style-as-form experiment starts fresh from zero.
+# Bump this suffix again on any future reset (keep bin/server.js
+# DRAFT_PROMPT_VARIANT_DEFS, scripts/active_experiments.py DESCRIPTIONS, and the
+# treatment_v3 gate in scripts/engagement_styles.py get_assigned_style_prompt in
+# sync).
 S4L_DRAFT_PROMPT_VARIANT=$(python3 -c "
 import random
 try:
@@ -1832,12 +1838,12 @@ try:
 except Exception:
     rate = 0.5
 rate = min(1.0, max(0.0, rate))
-print('treatment_v2' if random.random() < rate else 'control_v2')
-" 2>/dev/null || echo treatment_v2)
+print('treatment_v3' if random.random() < rate else 'control_v3')
+" 2>/dev/null || echo treatment_v3)
 export S4L_DRAFT_PROMPT_VARIANT
 log "Draft-prompt A/B arm: $S4L_DRAFT_PROMPT_VARIANT (rate=$DRAFT_PROMPT_AB_RATE)"
-if [ "$S4L_DRAFT_PROMPT_VARIANT" = "treatment_v2" ]; then
-    DRAFT_DIRECTIVE="Otherwise: draft a direct, natural reply that stands on its own as a useful contribution to the thread. Mention the matched project only when it is genuinely the most relevant thing to say, and state it plainly in one clause; most replies will not need it. Do NOT use the concede-then-reverse skeleton in ANY form. Banned openings include: 'X is the easy part/half/win, the hard part is Y'; 'X was never the [thing], it's Y'; 'X isn't the [problem], it's Y'; 'the real/actual/harder part is Y'; 'what actually breaks/ships/matters is Y'; 'the part nobody says/shows is Y'; 'X is solved, Y is what breaks'. If your draft contains that concede-then-reverse pivot, rewrite it from a different entry point. This rule OVERRIDES the assigned style's example when that example uses the skeleton: keep the style's intent, not its shape. Instead lead with substance from ONE entry point, and vary the entry point across replies: a concrete first-hand specific or number; a direct answer to the exact question asked; one sharp opinion with no hedge; a genuine question that moves the thread forward; or a relevant pointer. No warm-up framing sentence before the substance. Length is governed ENTIRELY by the per-style LENGTH LIMIT in the style block above; obey that target and ceiling, do not apply any other length rule here. NEVER em dashes. Apply the matched project's \`voice\` block from ALL_PROJECTS_JSON: follow voice.tone, never violate voice.never, mirror voice.examples / voice.examples_good when present. The matched project's learned_preferences block in ALL_PROJECTS_JSON is distilled human review feedback and is MANDATORY, not advisory: follow every learned_preferences.draft_style_notes entry when writing (it overrides the engagement style's structural template on conflict), and treat learned_preferences.audience_avoid / thread_avoid matches as strong reasons to skip the candidate. Never violate content_guardrails.do_not."
+if [ "$S4L_DRAFT_PROMPT_VARIANT" = "treatment_v3" ]; then
+    DRAFT_DIRECTIVE="Otherwise: draft a direct, natural reply that stands on its own as a useful contribution to the thread. Mention the matched project only when it is genuinely the most relevant thing to say, and state it plainly in one clause; most replies will not need it. THE ASSIGNED ENGAGEMENT STYLE IS THE FORM OF THIS DRAFT, not a flavor hint: the style block above defines the draft's structure, defining move, and length. Commit to that form BEFORE writing, and run the style block's self-check before returning the draft. Do NOT use the concede-then-reverse skeleton in ANY form. Banned openings include: 'X is the easy part/half/win, the hard part is Y'; 'X was never the [thing], it's Y'; 'X isn't the [problem], it's Y'; 'the real/actual/harder part is Y'; 'what actually breaks/ships/matters is Y'; 'the part nobody says/shows is Y'; 'X is solved, Y is what breaks'. If your draft contains that concede-then-reverse pivot, rewrite it from a different entry point. This ban OVERRIDES the assigned style's example when that example uses the skeleton: keep the style's defining move, express it without the skeleton. Lead with substance from ONE entry point and vary the entry point across replies: a concrete first-hand specific or number; a direct answer to the exact question asked; one sharp opinion with no hedge; a genuine question that moves the thread forward; or a relevant pointer. No warm-up framing sentence before the substance. Length is governed ENTIRELY by the per-style LENGTH LIMIT in the style block above; obey that target and ceiling, do not apply any other length rule here. NEVER em dashes. Apply the matched project's \`voice\` block from ALL_PROJECTS_JSON: follow voice.tone, never violate voice.never, mirror voice.examples / voice.examples_good when present. The matched project's learned_preferences block in ALL_PROJECTS_JSON is distilled human review feedback and is MANDATORY, not advisory, and it works TOGETHER with the engagement style on different layers: the style owns the FORM (structure, defining move, length) and learned_preferences.draft_style_notes own the voice, wording, and content choices INSIDE that form. When a preference seems to conflict with the style, keep the style's structure and satisfy the preference within it; never drop the style's defining move to satisfy a wording note. Treat learned_preferences.audience_avoid / thread_avoid matches as strong reasons to skip the candidate. Never violate content_guardrails.do_not."
 else
     DRAFT_DIRECTIVE="Otherwise: draft a reply using the best engagement style. Length is governed ENTIRELY by the per-style LENGTH LIMIT in the style block above; obey that target and ceiling, do not apply any other length rule here. NEVER em dashes. Apply the matched project's \`voice\` block from ALL_PROJECTS_JSON: follow voice.tone, never violate voice.never, mirror voice.examples / voice.examples_good when present. The matched project's learned_preferences block in ALL_PROJECTS_JSON is distilled human review feedback and is MANDATORY, not advisory: follow every learned_preferences.draft_style_notes entry when writing (it overrides the engagement style's structural template on conflict), and treat learned_preferences.audience_avoid / thread_avoid matches as strong reasons to skip the candidate. Never violate content_guardrails.do_not."
 fi
@@ -1846,20 +1852,28 @@ fi
 # growth: no product, no link, no CTA. The reply must add real value grounded in
 # the persona's first-hand material (the PERSONA CORPUS block + the persona voice
 # block), not concede-and-agree filler. Replaces the product-framed promotion
-# directives above, but is itself arm-aware (see below): treatment_v2 adds the
-# skeleton ban, control_v2 does not, so the A/B runs in this lane too.
+# directives above, but is itself arm-aware (see below): treatment_v3 adds the
+# skeleton ban + the two-layer style/preferences contract, control_v3 keeps the
+# plain persona directive, so the A/B runs in this lane too.
 if [ "${S4L_ACTIVE_LANE:-}" = "personal_brand" ]; then
-    # Arm-aware skeleton ban in the persona lane (2026-07-06): treatment_v2 adds the
-    # concede-then-reverse ban clause; control_v2 keeps the plain persona directive.
-    # This makes the A/B measurable in the persona lane too. The arm is stamped onto
-    # the card + surfaced (active_experiments.py no longer drops draft_prompt for
-    # personal_brand), so persona cards now show treatment_v2 / control_v2.
-    if [ "$S4L_DRAFT_PROMPT_VARIANT" = "treatment_v2" ]; then
-        PERSONA_SKELETON_BAN=" Also do NOT use the concede-then-reverse skeleton in ANY form: banned openings include 'X is the easy part/half/win, the hard part is Y', 'X was never the [thing], it's Y', 'X isn't the [problem], it's Y', 'the real/actual/harder part is Y', 'what actually breaks/ships/matters is Y', 'the part nobody says/shows is Y', and 'X is solved, Y is what breaks'; if a draft has that pivot, rewrite it from one of the entry points above. This OVERRIDES the assigned style's example when that example uses the skeleton: keep the style's intent, not its shape."
+    # Arm-aware persona lane (v3, 2026-07-10): treatment_v3 adds the
+    # concede-then-reverse ban clause AND swaps the learned_preferences
+    # relation from 'overrides the style on conflict' to the two-layer
+    # contract (style owns form, preferences own voice inside it);
+    # control_v3 keeps the plain persona directive. The style block itself
+    # (STYLES_BLOCK, rendered in this process) is also arm-aware, so the
+    # persona lane gets the style-as-FORM block on treatment automatically.
+    # The arm is stamped onto the card + surfaced (active_experiments.py no
+    # longer drops draft_prompt for personal_brand), so persona cards show
+    # treatment_v3 / control_v3.
+    if [ "$S4L_DRAFT_PROMPT_VARIANT" = "treatment_v3" ]; then
+        PERSONA_SKELETON_BAN=" Also do NOT use the concede-then-reverse skeleton in ANY form: banned openings include 'X is the easy part/half/win, the hard part is Y', 'X was never the [thing], it's Y', 'X isn't the [problem], it's Y', 'the real/actual/harder part is Y', 'what actually breaks/ships/matters is Y', 'the part nobody says/shows is Y', and 'X is solved, Y is what breaks'; if a draft has that pivot, rewrite it from one of the entry points above. This ban OVERRIDES the assigned style's example when that example uses the skeleton: keep the style's defining move, express it without the skeleton."
+        PERSONA_PREFS_RELATION="(learned_preferences work TOGETHER with the engagement style on different layers: the style owns the FORM, structure, defining move, and length; draft_style_notes own the voice and wording INSIDE that form; on apparent conflict keep the style's structure and satisfy the preference within it)"
     else
         PERSONA_SKELETON_BAN=""
+        PERSONA_PREFS_RELATION="(it overrides the engagement style's structural template on conflict)"
     fi
-    DRAFT_DIRECTIVE="Otherwise: draft a reply that stands on its own as a genuinely useful contribution to THIS thread. Ground it in the persona's real, first-hand experience from the PERSONA CORPUS block below (specific projects, real numbers, sharp opinions, actual failures) and in the persona's \`voice\` block from ALL_PROJECTS_JSON. Add exactly ONE of: a concrete specific from that lived experience, a sharp non-obvious opinion, a useful pointer, or a question that genuinely moves the thread forward. NEVER generic agreement ('makes sense', 'this is spot on', 'great point', 'the nuance here is').${PERSONA_SKELETON_BAN} This is a personal account, not a brand: sound like a real person in the thread. If web search is available and the thread hinges on a current fact, verify it before drafting rather than guessing. Length is governed ENTIRELY by the per-style LENGTH LIMIT in the style block above; obey that target and ceiling. NEVER em dashes. Follow voice.tone, never violate voice.never, mirror voice.examples / voice.examples_good when present. The persona's learned_preferences block in ALL_PROJECTS_JSON is distilled human review feedback and is MANDATORY, not advisory: follow every learned_preferences.draft_style_notes entry when writing (it overrides the engagement style's structural template on conflict), and treat learned_preferences.audience_avoid / thread_avoid matches as strong reasons to skip the candidate. Never violate content_guardrails.do_not."
+    DRAFT_DIRECTIVE="Otherwise: draft a reply that stands on its own as a genuinely useful contribution to THIS thread. Ground it in the persona's real, first-hand experience from the PERSONA CORPUS block below (specific projects, real numbers, sharp opinions, actual failures) and in the persona's \`voice\` block from ALL_PROJECTS_JSON. Add exactly ONE of: a concrete specific from that lived experience, a sharp non-obvious opinion, a useful pointer, or a question that genuinely moves the thread forward. NEVER generic agreement ('makes sense', 'this is spot on', 'great point', 'the nuance here is').${PERSONA_SKELETON_BAN} This is a personal account, not a brand: sound like a real person in the thread. If web search is available and the thread hinges on a current fact, verify it before drafting rather than guessing. Length is governed ENTIRELY by the per-style LENGTH LIMIT in the style block above; obey that target and ceiling. NEVER em dashes. Follow voice.tone, never violate voice.never, mirror voice.examples / voice.examples_good when present. The persona's learned_preferences block in ALL_PROJECTS_JSON is distilled human review feedback and is MANDATORY, not advisory: follow every learned_preferences.draft_style_notes entry when writing ${PERSONA_PREFS_RELATION}, and treat learned_preferences.audience_avoid / thread_avoid matches as strong reasons to skip the candidate. Never violate content_guardrails.do_not."
 fi
 
 # 2026-07-10 anti-sameness: --no-project-sections strips the multi-project
@@ -2194,6 +2208,27 @@ CRITICAL:
 # installs) treats --allowedTools as a one-value flag, so a space-separated second
 # tool would leak in as the prompt. On the box these flags ride through
 # claude_job.py; Desktop's own web search + the reworded prompt enable it there.
+# --- Prep-prompt snapshot (2026-07-11) ---------------------------------------
+# Persist the exact rendered PREP_PROMPT per batch so prompt-block presence is
+# verifiable after any release (grep the file), instead of reverse-engineering
+# it from package scripts. The queue's prompt-*.md files are transient work
+# files deleted on completion, and the generation trace deliberately carries
+# only the exemplar context, so this is the ONLY durable full-prompt record.
+# Local-only, newest 50 kept (file cleanup, not candidate-row retention; the
+# no-retention rule covers DB *_candidates rows). Never blocks the run.
+PREP_PROMPT_DIR="${S4L_STATE_DIR:-$HOME/.social-autoposter-mcp}/prep-prompts"
+if mkdir -p "$PREP_PROMPT_DIR" 2>/dev/null; then
+    _PP_FILE="$PREP_PROMPT_DIR/prep-prompt-$BATCH_ID.md"
+    if printf '%s' "$PREP_PROMPT" > "$_PP_FILE" 2>/dev/null; then
+        ls -t "$PREP_PROMPT_DIR"/prep-prompt-*.md 2>/dev/null | tail -n +51 | while IFS= read -r _pp_old; do
+            rm -f "$_pp_old"
+        done
+        log "[prep_prompt_snapshot] batch=$BATCH_ID bytes=$(wc -c < "$_PP_FILE" | tr -d ' ') path=$_PP_FILE"
+    else
+        log "WARN: prep-prompt snapshot write failed for batch=$BATCH_ID (non-fatal)"
+    fi
+fi
+
 PREP_OUTPUT=$(printf '%s' "$PREP_PROMPT" | "$REPO_DIR/scripts/run_claude.sh" "run-twitter-cycle-prep" --strict-mcp-config --mcp-config "$TW_MCP_CONFIG" --allowedTools WebSearch,WebFetch -p --output-format json --json-schema "$PREP_SCHEMA" 2>&1)
 
 echo "$PREP_OUTPUT" >> "$LOG_FILE"