@m13v/s4l 1.7.4-rc.4 → 1.7.4

package/scripts/engagement_styles.py

@@ -36,7 +36,7 @@ import json
 import os
 import random
 import sys as _sys_mod
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 
 # ── Style taxonomy ──────────────────────────────────────────────────
 
@@ -1341,6 +1341,106 @@ def pick_style_for_post(platform, context="posting",
     }
 
 
+# Days back a model_invented style still counts as "recent" for the Draft-B
+# exploration pool. The registry holds ~900 pre-2026-07-10 inventions that
+# are mostly clones of the agree-then-relocate skeleton (see the
+# invent_styles.py docstring); the exploration slot exists to trial the
+# standalone job's structurally-diverse output, not to resurrect those.
+# human_derived rows are NOT date-gated: they arrive one per platform per
+# day and least-used ordering naturally favors the fresh ones.
+EXPLORATION_INVENTED_MAX_AGE_DAYS = 14
+# Hard floor: never trial inventions from before the inline INVENT_RATE was
+# zeroed (2026-07-10). Anything older is the clone flood, regardless of how
+# recent the rolling window makes it look.
+EXPLORATION_INVENTED_EPOCH = datetime(2026, 7, 10, 21, 0,
+                                      tzinfo=timezone.utc)
+
+
+def pick_exploration_style(platform, context="posting", exclude=None,
+                           rng=None):
+    """Draft-B exploration picker (2026-07-11). NEVER invents.
+
+    Returns an assignment dict in the exact pick_style_for_post() shape
+    (so s4l_render_style_block and every downstream consumer work
+    unchanged) with an extra "source" key in {"human_derived",
+    "model_invented"}, or None when the pool is empty / anything fails
+    (caller falls back to the scored picker).
+
+    Pool: registry rows with kind='human_derived' (any age) plus
+    kind='model_invented' rows registered in the last
+    EXPLORATION_INVENTED_MAX_AGE_DAYS days. Selection is LEAST-USED first
+    (30-day post count on this platform via compute_target_distribution),
+    uniform among the up-to-5 least-used, so every new style gets trial
+    exposure instead of waiting behind the score-weighted sampler's
+    winner-take-most weights. This is the distribution channel for the
+    standalone invent_styles.py job; the review card's pick plus the
+    posted draft's engagement write the style's first real score, and
+    winners graduate into the Draft-A pool through the normal sampler.
+    """
+    rnd = rng or random
+    try:
+        never = set(PLATFORM_POLICY.get(platform, {}).get("never", []))
+        skip = set(exclude or ()) | never
+        registry = _fetch_registry_styles()
+        cutoff = max(
+            datetime.now(timezone.utc)
+            - timedelta(days=EXPLORATION_INVENTED_MAX_AGE_DAYS),
+            EXPLORATION_INVENTED_EPOCH,
+        )
+        pool = {}
+        for name, entry in registry.items():
+            if name in skip:
+                continue
+            if (entry.get("status") or "active") != "active":
+                continue
+            kind = entry.get("kind")
+            if kind == "human_derived":
+                pool[name] = entry
+            elif kind == "model_invented":
+                invented_at = _parse_iso_utc(entry.get("invented_at"))
+                if invented_at is not None and invented_at >= cutoff:
+                    pool[name] = entry
+        if not pool:
+            return None
+        usage = {r["style"]: int(r.get("n") or 0)
+                 for r in compute_target_distribution(platform,
+                                                      context=context)}
+        names = list(pool.keys())
+        rnd.shuffle(names)  # random tie order before the stable sort
+        names.sort(key=lambda s: usage.get(s, 0))
+        chosen = rnd.choice(names[:5])
+        entry = pool[chosen]
+        return {
+            "mode": "use",
+            "style": chosen,
+            "description": entry.get("description"),
+            "example": entry.get("example"),
+            "note": entry.get("note"),
+            "target_chars": entry.get("target_chars") or DEFAULT_TARGET_CHARS,
+            "source": entry.get("kind"),
+            "usage_n_30d": usage.get(chosen, 0),
+            "reference_styles": [],
+            "distribution_snapshot": [],
+            "picked_at": datetime.now(timezone.utc).isoformat(
+                timespec="seconds"),
+        }
+    except Exception:
+        return None
+
+
+def _parse_iso_utc(value):
+    """Parse an ISO timestamp into aware-UTC; None on any failure."""
+    if not value:
+        return None
+    try:
+        dt = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return dt.astimezone(timezone.utc)
+    except (ValueError, TypeError):
+        return None
+
+
 def get_assigned_style_prompt(platform, assignment, context="posting"):
     """Compact prompt block built from a pick_style_for_post() assignment.
 
@@ -1364,31 +1464,126 @@ 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.
-        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."
-        )
+        # 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(_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."
+            )
+            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(
+                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/feedback_digest.py

@@ -145,6 +145,13 @@ def _event_line(e: dict) -> str:
         if not dc.get("auto_selected"):
             parts.append("picked_draft_b_over_default_a")
             show_unchosen = True
+        elif dc.get("visited_other"):
+            # Clicked into B, then came back and approved A: an explicit
+            # head-to-head choice of the default, same strength as a switch
+            # (2026-07-10 user rule: only a zero-interaction approve is
+            # no-signal).
+            parts.append("chose_default_a_after_trying_b")
+            show_unchosen = True
         else:
             other_ms = dc.get("hover_b_ms") or 0
             if other_ms >= DRAFT_READ_MS:
@@ -256,7 +263,7 @@ NEW REVIEW EVENTS since the last digest ({len(rejected)} rejected, {len(no_reaso
 
 Categories: wrong_author = the thread's author/audience was a bad fit; off_topic = the thread itself was a bad fit; bad_draft = thread was fine but the written reply was off; other = see the note. "no_reason_given" means the user rejected without picking a category or typing a note: the rejection itself is real, but WHY is your inference from the author/thread/draft context alone, so treat it as weak evidence. It can corroborate a pattern that reasoned events already show, but a no_reason_given reject never justifies a new entry or an author block on its own, and 2+ of them agreeing still only justify an entry when the shared pattern in their context is unmistakable. "edited_before_approving" with an ORIGINAL/REWROTE pair means the user hand-corrected our draft before posting: the rewrite is a direct statement of the voice they want. Diff the pair; when 2+ edits show the same correction (a phrase type removed, a structure replaced, tone shifted, length cut), distill that recurring pattern into draft_style_notes. Ignore edit content that is lead-specific or cosmetic (typo fixes, one-off facts); learn only what generalizes. "user_checked=profile_click" means the user opened the author's profile before deciding (a strong author-quality signal even without a note). "[approved+loved]" means the user picked the heart in the approve row ("this was a really good one"; approve_level_N in interactions carries the strength, 2 = best of the best): strong positive evidence for audience_prefer and thread selection, worth roughly two plain approvals.
 
-Two-draft cards show a "did NOT pick" pair. "picked_draft_b_over_default_a" means the card offered two drafts with A preselected and the user deliberately clicked into B and approved it: a direct head-to-head preference for the picked draft over the shown alternative, evidence on par with a hand rewrite. "kept_default_a_after_reading_b=Xs" means they kept the preselected A but spent Xs with the pointer over B first: an informed keep, weaker than a switch (reading B does not prove they weighed it; treat like no_reason_given, corroborating a pattern that stronger events already show rather than founding one). "second_draft_not_read" means they approved the default without reading the alternative: NO pairwise signal, never infer anything against the unread draft. When 2+ pairwise events agree, diff the picked texts against the not-picked ones and distill WHAT recurs (tone, structure, length, opener type, directness) into draft_style_notes; the "styles:" line names each side's engagement style, useful when the same style keeps winning or losing.
+Two-draft cards show a "did NOT pick" pair. "picked_draft_b_over_default_a" means the card offered two drafts with A preselected and the user deliberately clicked into B and approved it: a direct head-to-head preference for the picked draft over the shown alternative, evidence on par with a hand rewrite. "chose_default_a_after_trying_b" means they clicked into B (trying it as the selection) and then came back and approved A: equally explicit, the same head-to-head strength as a switch, just with the default as the winner. "kept_default_a_after_reading_b=Xs" means they kept the preselected A but spent Xs with the pointer over B first: an informed keep, weaker than either explicit choice (reading B does not prove they weighed it; treat like no_reason_given, corroborating a pattern that stronger events already show rather than founding one). "second_draft_not_read" means they approved the default without touching or reading the alternative: NO pairwise signal, never infer anything against the unread draft. When 2+ pairwise events agree, diff the picked texts against the not-picked ones and distill WHAT recurs (tone, structure, length, opener type, directness) into draft_style_notes; the "styles:" line names each side's engagement style, useful when the same style keeps winning or losing.
 
 You can also block SPECIFIC authors via the plan's block_authors list. A block is a permanent hard exclusion of that one handle from all future thread selection, so it is YOUR judgment call, never automatic. Block when the evidence is strong: a wrong_author reject IS a direct human statement about that author (especially with profile_click), and the author context (author_followers, their post, found_via_topic) or the user's note confirms the account itself was the problem rather than the topic. Do NOT block when the reject looks topic-driven (off_topic/bad_draft on a reasonable account) or when you are unsure; the generalizable TYPE entry in audience_avoid is the softer tool for that.
 
@@ -386,6 +393,22 @@ def _is_actionable(e: dict) -> bool:
     # as actionable as a reject (and it feeds edit_examples).
     if e.get("edited"):
         return True
+    # Any pairwise draft signal triggers the digest (2026-07-10 user rule,
+    # widened same evening): an explicit choice (switched to B, or tried B
+    # and came back to A) is style evidence on par with an edit, and even a
+    # hover-read of the other draft (>= DRAFT_READ_MS) is a small but real
+    # signal that must flow through the pipeline rather than bank forever
+    # behind the plain-approvals gate. The PROMPT still weights the tiers
+    # (explicit strong, hover-read weak/corroborating); this gate only
+    # decides when a Claude turn is worth burning. A zero-interaction
+    # approve (second_draft_not_read) remains non-actionable: no signal.
+    dc = _draft_choice(e)
+    if dc and (
+        not dc.get("auto_selected")
+        or dc.get("visited_other")
+        or (dc.get("hover_b_ms") or 0) >= DRAFT_READ_MS
+    ):
+        return True
     return bool((e.get("reject_note") or "").strip())
 
 

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)