@m13v/s4l 1.7.2 → 1.7.4-rc.1

package/scripts/voice_exemplars.py

@@ -0,0 +1,424 @@
+#!/usr/bin/env python3
+"""Turn a scan_x_profile.py corpus into durable author-voice exemplars.
+
+WHERE THIS FITS: scan_x_profile.py (run at onboarding right after connect_x,
+or later via build_persona.py gather) returns the user's real posts + replies
+ranked by engagement (`top_posts` / `top_replies`, each with likes/retweets/
+replies, the parent tweet replied to, and thread continuations). This script is
+the single deterministic writer that persists them where the drafters already
+look:
+
+  1. config.json -> project.voice.examples (list of strings). Every drafting
+     prompt already says "mirror voice.examples / voice.examples_good when
+     present": the twitter cycle (both promotion and personal_brand lanes, via
+     ALL_PROJECTS_JSON), post_reddit.py, engage_reddit.py, post_github.py, and
+     run_moltbook_cycle.py. Writing this ONE field feeds every lane on every
+     platform with zero prompt changes.
+  2. persona_corpus.txt (persona project only) -> a marked, regenerable
+     exemplar section with the top posts (incl. thread continuations) and top
+     replies WITH their parent context and stats. The personal_brand lane
+     inlines this file into the draft prompt.
+
+Selection: prefers replies with real engagement and enough text to show voice
+(skips throwaway one-liners below --min-chars unless nothing else exists).
+Stats are framed RELATIVELY ("top of the N scanned replies") because absolute
+numbers on small accounts mean nothing to the model.
+
+Safety: never clobbers hand-written voice.examples. It only replaces examples
+it wrote itself (voice.examples_scanned_at present) or fills an empty field;
+use --force to override. Config writes are atomic (tmp + replace), matching
+build_persona.py.
+
+Usage:
+  # After a scan (writes voice.examples; also corpus section if project is the persona):
+  python3 scripts/scan_x_profile.py > /tmp/scan.json
+  python3 scripts/voice_exemplars.py apply --scan /tmp/scan.json --project MyProject
+
+  # Preview without writing:
+  python3 scripts/voice_exemplars.py apply --scan /tmp/scan.json --project MyProject --dry-run
+
+  # Default project = the persona project (persona:true) when --project omitted.
+
+Accepts either raw scan_x_profile.py output or a build_persona.py gather blob
+(auto-detects sources.x).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+
+import s4l_mode  # noqa: E402
+
+EXEMPLARS_START = "=== S4L SCANNED EXEMPLARS START (auto-generated by voice_exemplars.py; regenerated on rescan, do not hand-edit) ==="
+EXEMPLARS_END = "=== S4L SCANNED EXEMPLARS END ==="
+
+
+def _score(item: dict) -> int:
+    """Mirror scan_x_profile.rank_top's weighting for scans that predate it."""
+    if "engagement_score" in item:
+        return int(item["engagement_score"] or 0)
+    return (int(item.get("likes") or 0) * 3
+            + int(item.get("retweets") or 0) * 5
+            + int(item.get("replies") or 0) * 2)
+
+
+def _load_scan(path: str) -> dict:
+    data = json.loads(Path(path).expanduser().read_text())
+    # build_persona.py gather embeds the raw scan under sources.x
+    if "sources" in data and isinstance(data["sources"], dict):
+        x = data["sources"].get("x") or {}
+        if x.get("ok"):
+            return x
+        raise SystemExit(f"gather blob's x source is not ok: {x.get('error')}")
+    return data
+
+
+def _pick(items: list, top: int, min_chars: int) -> list:
+    """Engagement-ranked, but a reply must have enough text to show voice.
+    Short high-engagement one-liners get skipped while longer candidates exist;
+    if the account only has one-liners, fall back rather than return nothing."""
+    ranked = sorted(items or [], key=_score, reverse=True)
+    long_enough = [i for i in ranked if len((i.get("text") or "").strip()) >= min_chars]
+    picked = long_enough[:top]
+    if not picked:
+        picked = ranked[:top]
+    return picked
+
+
+def _reply_pool(scan: dict) -> list:
+    """Select from the FULL scanned reply list, not the scanner's pre-truncated
+    top_replies (length-filtering a 5-item list can leave one survivor when the
+    account's best-engaging replies are one-liners). top_replies is the
+    fallback for older scans / gather blobs that dropped the full list."""
+    return scan.get("comments") or scan.get("top_replies") or []
+
+
+def _post_pool(scan: dict) -> list:
+    """Full post list, but prefer the enriched top_posts entry where one exists
+    (it carries the thread continuation and untruncated permalink text)."""
+    top = scan.get("top_posts") or []
+    rest = scan.get("posts") or []
+    by_key = {(p.get("id") or p.get("url") or p.get("text", "")[:80]): p for p in rest}
+    for p in top:
+        by_key[(p.get("id") or p.get("url") or p.get("text", "")[:80])] = p
+    return list(by_key.values())
+
+
+def _stats_note(item: dict, total: int, kind: str) -> str:
+    bits = []
+    for key, label in (("likes", "likes"), ("retweets", "reposts"), ("replies", "replies")):
+        v = int(item.get(key) or 0)
+        if v:
+            bits.append(f"{v} {label}")
+    eng = ", ".join(bits) if bits else "no engagement yet"
+    return f"{eng}; among their best of {total} scanned {kind}"
+
+
+def format_examples(scan: dict, top: int, min_chars: int) -> list[str]:
+    """voice.examples strings: verbatim reply first (the voice signal), then a
+    parenthesized context annotation (real stats + what it replied to). Plain
+    strings because every consumer joins/inlines them as-is."""
+    replies = _reply_pool(scan)
+    total = int((scan.get("counts") or {}).get("comments") or len(replies))
+    out = []
+    for r in _pick(replies, top, min_chars):
+        text = (r.get("text") or "").strip()
+        if not text:
+            continue
+        note = _stats_note(r, total, "replies")
+        parent = r.get("parent") or {}
+        if parent.get("text"):
+            ptxt = " ".join(parent["text"].split())[:140]
+            note += f'; replying to {parent.get("author") or "someone"}: "{ptxt}"'
+        out.append(f'"{text}" (their real reply, {note})')
+    return out
+
+
+def format_corpus_section(scan: dict, top: int, min_chars: int) -> str:
+    """The persona_corpus.txt block: richer than voice.examples (adds top posts
+    and full thread continuations). Regenerated wholesale between the markers."""
+    handle = scan.get("handle") or "?"
+    counts = scan.get("counts") or {}
+    lines = [EXEMPLARS_START,
+             f"@{handle}'s own top-performing posts and replies, ranked by real "
+             f"engagement across {counts.get('posts', '?')} posts and "
+             f"{counts.get('comments', '?')} replies scanned. Verbatim. This is "
+             "the voice and the bar: ground drafts in this register.", ""]
+    posts = _pick(_post_pool(scan), top, min_chars)
+    if posts:
+        lines.append("TOP POSTS:")
+        for p in posts:
+            lines.append(f"- ({_stats_note(p, int(counts.get('posts') or len(posts)), 'posts')}) {p.get('text', '').strip()}")
+            for cont in (p.get("thread") or [])[1:]:
+                lines.append(f"  [thread continuation] {cont.strip()}")
+        lines.append("")
+    replies = _pick(_reply_pool(scan), top, min_chars)
+    if replies:
+        lines.append("TOP REPLIES (with what they replied to):")
+        for r in replies:
+            parent = r.get("parent") or {}
+            if parent.get("text"):
+                ptxt = " ".join(parent["text"].split())[:200]
+                lines.append(f'- {parent.get("author") or "someone"} wrote: "{ptxt}"')
+                lines.append(f"  their reply ({_stats_note(r, int(counts.get('comments') or len(replies)), 'replies')}): {r.get('text', '').strip()}")
+            else:
+                lines.append(f"- their reply ({_stats_note(r, int(counts.get('comments') or len(replies)), 'replies')}): {r.get('text', '').strip()}")
+    lines.append(EXEMPLARS_END)
+    return "\n".join(lines)
+
+
+def _upsert_corpus_section(corpus_path: Path, section: str) -> str:
+    """Replace the marked section in persona_corpus.txt, or prepend it (top of
+    file for salience) when absent. Returns what happened."""
+    if corpus_path.exists():
+        body = corpus_path.read_text()
+        if EXEMPLARS_START in body and EXEMPLARS_END in body:
+            pre = body.split(EXEMPLARS_START)[0]
+            post = body.split(EXEMPLARS_END, 1)[1]
+            corpus_path.write_text((pre + section + post).strip() + "\n")
+            return "replaced"
+        corpus_path.write_text(section + "\n\n" + body.strip() + "\n")
+        return "prepended"
+    corpus_path.write_text(section + "\n")
+    return "created"
+
+
+def _is_hand_written(proj: dict) -> bool:
+    """examples present but never stamped by us = a human typed them."""
+    voice = proj.get("voice")
+    return (isinstance(voice, dict) and bool(voice.get("examples"))
+            and not voice.get("examples_scanned_at"))
+
+
+def _set_examples(proj: dict, scan: dict, top: int, min_chars: int,
+                  force: bool) -> "tuple[bool, str, list]":
+    """Write voice.examples onto proj IN PLACE. Returns (ok, reason, examples)."""
+    examples = format_examples(scan, top, min_chars)
+    if not examples:
+        return False, "no_usable_replies", []
+    if _is_hand_written(proj) and not force:
+        return False, "hand_written_examples", []
+    voice = proj.get("voice")
+    if not isinstance(voice, dict):
+        voice = {"tone": voice} if voice else {}
+        proj["voice"] = voice
+    voice["examples"] = examples
+    voice["examples_scanned_at"] = datetime.now(timezone.utc).isoformat(timespec="seconds")
+    return True, "ok", examples
+
+
+def _write_config(cfg_path: Path, cfg: dict) -> None:
+    tmp = cfg_path.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(cfg, ensure_ascii=False, indent=2) + "\n")
+    tmp.replace(cfg_path)
+
+
+def cmd_apply(args) -> int:
+    cfg_path = Path(args.config).expanduser() if args.config else s4l_mode.config_path()
+    scan_src = args.scan or str(cfg_path.parent / "last_profile_scan.json")
+    if not Path(scan_src).expanduser().exists():
+        print(json.dumps({"ok": False, "error": f"no scan at {scan_src}; run "
+                          "scan_x_profile.py first (it writes last_profile_scan.json) "
+                          "or pass --scan"}))
+        return 1
+    scan = _load_scan(scan_src)
+    if not scan.get("ok"):
+        print(json.dumps({"ok": False, "error": f"scan not ok: {scan.get('error')}"}))
+        return 1
+
+    cfg = json.loads(cfg_path.read_text())
+    projects = cfg.get("projects", [])
+    name = args.project or s4l_mode.persona_name()
+    proj = next((p for p in projects if p.get("name") == name), None)
+    if proj is None:
+        print(json.dumps({"ok": False, "error": f"project {name!r} not in {cfg_path} "
+                          "(pass --project, or configure a persona project)"}))
+        return 2
+
+    ok, reason, examples = _set_examples(proj, scan, args.top, args.min_chars, args.force)
+    if not ok and reason == "no_usable_replies":
+        print(json.dumps({"ok": False, "error": "scan has no usable replies to build examples from"}))
+        return 1
+    if not ok:
+        print(json.dumps({"ok": False, "error":
+                          f"{name}.voice.examples already has hand-written entries; "
+                          "rerun with --force to replace them",
+                          "existing": (proj.get("voice") or {}).get("examples")}))
+        return 3
+
+    is_persona = proj.get("persona") is True
+    corpus_path = cfg_path.parent / "persona_corpus.txt"
+    section = format_corpus_section(scan, args.top, args.min_chars) if is_persona else None
+
+    if args.dry_run:
+        print(json.dumps({"ok": True, "dry_run": True, "project": name,
+                          "voice_examples": examples,
+                          "corpus_section": section}, ensure_ascii=False, indent=2))
+        return 0
+
+    _write_config(cfg_path, cfg)
+
+    corpus_action = None
+    if section:
+        corpus_action = _upsert_corpus_section(corpus_path, section)
+
+    print(json.dumps({"ok": True, "project": name,
+                      "voice_examples_written": len(examples),
+                      "corpus_sidecar": str(corpus_path) if corpus_action else None,
+                      "corpus_action": corpus_action}, ensure_ascii=False))
+    return 0
+
+
+# --------------------------------------------------------------------------- #
+# backfill: one-shot catch-up for installs onboarded BEFORE this feature.
+# --------------------------------------------------------------------------- #
+_BROWSER_LOCK = Path("/tmp/social-autoposter-twitter-browser.lock")
+
+
+def _try_browser_lock() -> "Path | None":
+    """BAIL-ON-BUSY acquire of the pipelines' twitter-browser lock (same mkdir
+    protocol as skill/lock.sh, without its queue: the backfill is opportunistic
+    and simply retries on a later boot rather than waiting behind a cycle)."""
+    try:
+        _BROWSER_LOCK.mkdir()
+    except OSError:
+        return None
+    try:
+        (_BROWSER_LOCK / "pid").write_text(f"{os.getpid()}\n")
+        (_BROWSER_LOCK / "expires_at").write_text(f"{int(time.time()) + 600}\n")
+    except Exception:
+        pass
+    return _BROWSER_LOCK
+
+
+def _release_browser_lock() -> None:
+    try:
+        pid = (_BROWSER_LOCK / "pid").read_text().strip()
+        if pid == str(os.getpid()):
+            shutil.rmtree(_BROWSER_LOCK)
+    except Exception:
+        pass
+
+
+def cmd_backfill(args) -> int:
+    """Called best-effort on MCP boot. If the persona project predates the
+    exemplar feature (no voice.examples_scanned_at), run a fresh profile scan
+    and apply. Scoped to the PERSONA project only: every install provisions one
+    at onboarding, and it is where the author's own voice lives; product
+    projects pick exemplars up on their next project_config save instead. The
+    corpus write is additive (the marked section is the only thing replaced;
+    dictation and hand-added material stay). Rate-limited by a marker file so a
+    down browser doesn't retrigger a scan on every boot."""
+    cfg_path = Path(args.config).expanduser() if args.config else s4l_mode.config_path()
+    if not cfg_path.exists():
+        print(json.dumps({"ok": True, "did": "nothing", "reason": "no_config"}))
+        return 0
+    cfg = json.loads(cfg_path.read_text())
+    personas = [p for p in cfg.get("projects", []) if p.get("persona") is True]
+    eligible = [p for p in personas
+                if not (isinstance(p.get("voice"), dict) and p["voice"].get("examples_scanned_at"))
+                and not _is_hand_written(p)]
+    if not eligible:
+        print(json.dumps({"ok": True, "did": "nothing", "reason": "already_done_or_hand_written"}))
+        return 0
+
+    marker = cfg_path.parent / ".voice_exemplars_backfill.json"
+    try:
+        last = json.loads(marker.read_text()).get("last_attempt", 0)
+    except Exception:
+        last = 0
+    if time.time() - last < args.min_hours_between * 3600:
+        print(json.dumps({"ok": True, "did": "nothing", "reason": "attempted_recently"}))
+        return 0
+    marker.write_text(json.dumps({"last_attempt": int(time.time())}) + "\n")
+
+    if not args.no_scan:
+        lock = _try_browser_lock()
+        if lock is None:
+            print(json.dumps({"ok": True, "did": "nothing", "reason": "browser_busy"}))
+            return 0
+        try:
+            py = os.environ.get("S4L_PYTHON") or sys.executable or "python3"
+            r = subprocess.run([py, str(HERE / "scan_x_profile.py")],
+                               capture_output=True, text=True, timeout=300)
+        except Exception as e:
+            print(json.dumps({"ok": False, "did": "nothing", "reason": f"scan_failed: {e}"}))
+            return 0
+        finally:
+            _release_browser_lock()
+        last_line = (r.stdout or "").strip().splitlines()[-1:] or ["{}"]
+        try:
+            scan_res = json.loads(last_line[0])
+        except Exception:
+            scan_res = {}
+        if not scan_res.get("ok"):
+            print(json.dumps({"ok": False, "did": "nothing",
+                              "reason": f"scan_not_ok: {scan_res.get('state') or 'no_json'}"}))
+            return 0
+
+    scan_path = cfg_path.parent / "last_profile_scan.json"
+    if not scan_path.exists():
+        print(json.dumps({"ok": False, "did": "nothing", "reason": "no_scan_sidecar"}))
+        return 0
+    scan = _load_scan(str(scan_path))
+
+    applied = []
+    for proj in eligible:
+        ok, reason, examples = _set_examples(proj, scan, args.top, args.min_chars, False)
+        if ok:
+            applied.append(proj["name"])
+            if proj.get("persona") is True:
+                section = format_corpus_section(scan, args.top, args.min_chars)
+                _upsert_corpus_section(cfg_path.parent / "persona_corpus.txt", section)
+    if applied:
+        _write_config(cfg_path, cfg)
+    print(json.dumps({"ok": True, "did": "backfilled" if applied else "nothing",
+                      "projects": applied}, ensure_ascii=False))
+    return 0
+
+
+def main(argv) -> int:
+    ap = argparse.ArgumentParser(description="Persist scanned top posts/replies as author-voice exemplars")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    a = sub.add_parser("apply", help="write voice.examples (+ persona corpus section)")
+    a.add_argument("--scan", default=None,
+                   help="scan_x_profile.py JSON or build_persona gather blob "
+                        "(default: <config dir>/last_profile_scan.json, written by the scanner)")
+    a.add_argument("--project", default=None, help="config.json project name (default: the persona project)")
+    a.add_argument("--config", default=None, help="config.json path override (testing)")
+    a.add_argument("--top", type=int, default=5, help="max exemplars per surface")
+    a.add_argument("--min-chars", type=int, default=40,
+                   help="skip replies shorter than this when longer ones exist")
+    a.add_argument("--force", action="store_true", help="replace hand-written voice.examples")
+    a.add_argument("--dry-run", action="store_true", help="print what would be written")
+    a.set_defaults(func=cmd_apply)
+
+    b = sub.add_parser("backfill",
+                       help="one-shot catch-up on boot: scan + apply for a persona "
+                            "that predates the exemplar feature")
+    b.add_argument("--config", default=None, help="config.json path override (testing)")
+    b.add_argument("--top", type=int, default=5)
+    b.add_argument("--min-chars", type=int, default=40)
+    b.add_argument("--min-hours-between", type=float, default=24.0,
+                   help="rate limit between scan attempts")
+    b.add_argument("--no-scan", action="store_true",
+                   help="skip the live scan and use the existing last_profile_scan.json")
+    b.set_defaults(func=cmd_backfill)
+
+    args = ap.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/skill/run-draft-and-publish.sh

@@ -11,9 +11,10 @@
 #     review-queue cards the menu bar shows. Without this merge the cycle's
 #     plan would sit in a /tmp batch file nobody reads.
 #   - draft-only OFF (operator opt-out via `s4l_mode.py draft-only off`,
-#     promotion-lane cycles only): DRAFT_ONLY=0 — the cycle posts its top-1
-#     pick autonomously, gated by the rolling virality bar. Persona cycles
-#     keep making cards either way.
+#     single global switch across EVERY lane as of 2026-07-08): DRAFT_ONLY=0
+#     — the cycle posts its top-1 pick autonomously; promotion additionally
+#     gated by the rolling virality bar. Persona cycles also post
+#     autonomously when the flag is off; they no longer stay draft-only.
 set -uo pipefail
 
 # SAPS_->S4L_ env mirror (brand rename 2026-07-03): old plists/tasks still

package/skill/run-twitter-cycle.sh

@@ -1824,17 +1824,30 @@ if [ "${S4L_ACTIVE_LANE:-}" = "personal_brand" ]; then
     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."
 fi
 
+# 2026-07-10 anti-sameness: --no-project-sections strips the multi-project
+# winner corpus (~400 lines of "Top Posts by Project" + summary table) that
+# used to ride along in EVERY draft prompt and homogenize drafts. The prep
+# session now queries per-project winners on demand AFTER routing a
+# candidate (see PROJECT TOP PERFORMERS section in PREP_PROMPT below).
 if [ -n "$PICKED_STYLE" ]; then
-    TOP_REPORT=$(python3 "$REPO_DIR/scripts/top_performers.py" --platform twitter --style "$PICKED_STYLE" 2>/dev/null || echo "(top performers report unavailable)")
+    TOP_REPORT=$(python3 "$REPO_DIR/scripts/top_performers.py" --platform twitter --style "$PICKED_STYLE" --no-project-sections 2>/dev/null || echo "(top performers report unavailable)")
 else
-    TOP_REPORT=$(python3 "$REPO_DIR/scripts/top_performers.py" --platform twitter 2>/dev/null || echo "(top performers report unavailable)")
+    TOP_REPORT=$(python3 "$REPO_DIR/scripts/top_performers.py" --platform twitter --no-project-sections 2>/dev/null || echo "(top performers report unavailable)")
 fi
 if [ -n "$PICKED_STYLE_B" ]; then
-    TOP_REPORT_B=$(python3 "$REPO_DIR/scripts/top_performers.py" --platform twitter --style "$PICKED_STYLE_B" 2>/dev/null || echo "(top performers report unavailable)")
+    TOP_REPORT_B=$(python3 "$REPO_DIR/scripts/top_performers.py" --platform twitter --style "$PICKED_STYLE_B" --no-project-sections 2>/dev/null || echo "(top performers report unavailable)")
 else
-    TOP_REPORT_B=$(python3 "$REPO_DIR/scripts/top_performers.py" --platform twitter 2>/dev/null || echo "(top performers report unavailable)")
+    TOP_REPORT_B=$(python3 "$REPO_DIR/scripts/top_performers.py" --platform twitter --no-project-sections 2>/dev/null || echo "(top performers report unavailable)")
 fi
 
+# --- Cross-cycle self-memory (anti-repetition) ------------------------------
+# 2026-07-10: the prep session never used to see this account's own recent
+# replies across threads (author_history_block is per-author only), so it
+# recycled the same openers and sentence skeletons cycle after cycle. This
+# block is NEGATIVE context, rendered with explicit do-not-imitate rules by
+# recent_self_posts.py. Empty string on any failure; never blocks the cycle.
+RECENT_SELF_BLOCK=$(python3 "$REPO_DIR/scripts/recent_self_posts.py" --platform twitter --limit 20 2>/dev/null || echo "")
+
 # --- Generation trace -------------------------------------------------------
 # Snapshot the few-shot context this cycle will feed to Claude — top_performers
 # report, top_queries from Phase 1, supply signal, dud queries — and write to a
@@ -2032,6 +2045,13 @@ $CORPUS_BLOCK
 Each candidate has a 'Project match' field. Use that project unless the thread content clearly better fits another project.
 All project configs: $ALL_PROJECTS_JSON
 
+## PROJECT TOP PERFORMERS (query on demand, do NOT skip routing first)
+The feedback reports below carry a per-style exemplar only; project winners are no longer bulk-injected. AFTER you have decided which project a candidate's draft is for, you MAY pull that project's own recent winners (last 30 days, ranked by real click rate) when you are unsure how this product converts in replies:
+   python3 $REPO_DIR/scripts/top_performers.py --platform twitter --project 'PROJECT_NAME' --top 3 --brief
+(PROJECT_NAME exactly as it appears in the candidate's 'Project match' / config.json.) Treat the results as evidence of which CLAIMS and ANGLES landed for that product, never as structural templates: do not copy their sentence shape, opener, or pivot wording. One call per project at most; skip the call entirely for projects you already queried this session.
+
+$RECENT_SELF_BLOCK
+
 ## DRAFT A: assigned style + feedback from past performance
 $TOP_REPORT