@m13v/s4l 1.7.4-rc.2 → 1.7.4-rc.21

package/scripts/active_experiments.py

@@ -40,16 +40,39 @@ ENV_PREFIX = "S4L_EXP_"
 # Keep draft_prompt entries in sync with bin/server.js
 # DRAFT_PROMPT_VARIANT_DEFS and the arm strings in run-twitter-cycle.sh.
 DESCRIPTIONS = {
+    "draft_b_source": {
+        "human_derived": (
+            "Draft B explore slot: style distilled from real top-performing "
+            "human replies (daily synthesizer), least-used first"
+        ),
+        "model_invented": (
+            "Draft B explore slot: freshly invented style from the "
+            "standalone invention job (post 2026-07-10), least-used first"
+        ),
+        "scored_fallback": (
+            "Draft B explore pool was empty; fell back to a second scored "
+            "pick from the proven-style pool"
+        ),
+    },
     "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",
     },
@@ -99,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/autopilot_stall_watch.py

@@ -47,13 +47,13 @@ import identity  # noqa: E402  (lives next to this file in scripts/)
 s4l_env.mirror()
 
 # Keep in sync with AUTOPILOT_STALL_SECONDS (menubar) / AUTOPILOT_STALL_MS (index.ts).
-STALL_SECONDS = 180
+STALL_SECONDS = 1200
 # A job CLAIMED but never finished (sits in running/ this long) means a worker
 # picked it up and then died mid-run — the claude -p drafting child never came up
 # or crashed. Must be generous enough to clear the longest real drafting turn so a
 # healthy run never trips it. Keep in sync with AUTOPILOT_RUNNING_STALL_SECONDS
 # (menubar). See _oldest_running_age.
-RUNNING_STALL_SECONDS = 900
+RUNNING_STALL_SECONDS = 1200
 # Require the stall to persist this many consecutive checks before paging, so a
 # transient slow claim (e.g. right after a Claude restart) doesn't false-alarm.
 # At StartInterval 120 that is ~6 min of continuous stall.

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

@@ -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 '