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

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/scripts/recent_self_posts.py

@@ -95,6 +95,12 @@ def build_block(platform, limit):
             "order_by": "posted_at",
             "order_dir": "desc",
             "limit": str(limit),
+            # Scope to THIS install's own posts (server filters on the
+            # authenticated X-Installation identity). Without this the
+            # default read returns the whole fleet's posts and the block
+            # would claim another account's replies as "yours"
+            # (found 2026-07-10: 8 of 20 rows were another install's).
+            "own_install": "true",
         },
     )
     rows = ((resp or {}).get("data") or {}).get("posts") or []

package/scripts/scan_x_profile.py

@@ -311,6 +311,50 @@ def scrape_timeline(send, me: str, want: int, max_scrolls: int = 30,
     return items[:want]
 
 
+def _own_posted_ids() -> set:
+    """Status ids of everything S4L itself has posted from this install, via
+    /api/v1/posts (install-scoped by the X-Installation header). Used to keep
+    the bot's own output OUT of the author-voice exemplar pool: on accounts
+    where S4L has been active, a recency scan is dominated by S4L drafts, and
+    feeding those back as 'the author's voice' is a feedback loop. Best-effort:
+    any failure (offline, fresh install, no API) returns an empty set and the
+    scan proceeds unfiltered."""
+    try:
+        sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+        from http_api import api_get  # noqa: PLC0415
+        import re
+        ids: set = set()
+        # The route caps limit at 500, so walk the FULL posting history with a
+        # forward posted_at cursor (order_dir=asc + since>=). On prolific
+        # accounts a single newest-500 page misses older S4L posts that the
+        # profile scan still reaches (bit the operator account: 12.8k posted
+        # statuses, 2 of 5 picked exemplars were S4L's own). The since filter
+        # is inclusive, so overlap rows dedupe via the set; a page whose max
+        # posted_at equals the cursor would loop and breaks instead.
+        cursor = None
+        for _ in range(80):  # hard cap 40k statuses
+            q = {"platform": "twitter", "has_our_url": "true", "limit": 500,
+                 "order_by": "posted_at", "order_dir": "asc"}
+            if cursor:
+                q["since"] = cursor
+            resp = api_get("/api/v1/posts", q)
+            rows = ((resp or {}).get("data") or {}).get("posts") or []
+            for r in rows:
+                m = re.search(r"/status/(\d+)", str(r.get("our_url") or ""))
+                if m:
+                    ids.add(m.group(1))
+            if len(rows) < 500:
+                break
+            page_max = max((r.get("posted_at") or "" for r in rows), default="")
+            if not page_max or page_max == cursor:
+                break
+            cursor = page_max
+        return ids
+    except Exception as e:
+        print(f"[scan_x_profile] own-posts exclusion unavailable: {e}", file=sys.stderr)
+        return set()
+
+
 # --------------------------------------------------------------------------- #
 # Engagement ranking + thread expansion for exemplar extraction.
 # --------------------------------------------------------------------------- #
@@ -409,8 +453,8 @@ GROUNDING_INSTRUCTIONS = (
 def main() -> int:
     ap = argparse.ArgumentParser()
     ap.add_argument("--handle", default=None, help="@handle to scan (default: live logged-in handle)")
-    ap.add_argument("--posts", type=int, default=20, help="max original posts to collect")
-    ap.add_argument("--comments", type=int, default=50, help="max replies/comments to collect")
+    ap.add_argument("--posts", type=int, default=60, help="max original posts to collect")
+    ap.add_argument("--comments", type=int, default=150, help="max replies/comments to collect")
     ap.add_argument("--top", type=int, default=5, help="how many top posts/replies to rank")
     ap.add_argument("--expand-threads", type=int, default=3,
                     help="visit this many top posts' permalinks to capture thread "
@@ -446,21 +490,37 @@ def main() -> int:
                                expect=f"/{handle}")
         profile = scrape_profile(send) if on_profile else {}
 
-        # 2. Original posts (current page = posts tab).
-        posts = scrape_timeline(send, handle, args.posts) if on_profile else []
+        # 2. Everything S4L itself posted from this install gets excluded from
+        #    BOTH surfaces (posts and replies): the exemplars must be the
+        #    human's writing, not the bot's own output echoed back.
+        s4l_ids = _own_posted_ids()
+        if s4l_ids:
+            print(f"[scan_x_profile] excluding {len(s4l_ids)} s4l-posted statuses "
+                  "from the exemplar pool", file=sys.stderr)
+
+        # 3. Original posts (current page = posts tab). max_scrolls tracks the
+        #    requested depth: the scan is programmatic, so scrolling deeper
+        #    costs only time, and end-of-feed stall detection stops it early
+        #    on small accounts.
+        posts = (scrape_timeline(send, handle, args.posts,
+                                 max_scrolls=max(30, args.posts),
+                                 exclude_ids=s4l_ids)
+                 if on_profile else [])
         post_ids = {p.get("id") for p in posts if p.get("id")}
 
-        # 3. Replies / comments = the user's own articles on /with_replies that
+        # 4. Replies / comments = the user's own articles on /with_replies that
         #    are NOT among the original posts (set subtraction, not DOM text).
         on_replies = _navigate(send, f"https://x.com/{handle}/with_replies",
                                settle=4.0, expect=f"/{handle}/with_replies")
         comments = (
-            scrape_timeline(send, handle, args.comments, exclude_ids=post_ids,
+            scrape_timeline(send, handle, args.comments,
+                            max_scrolls=max(30, args.comments),
+                            exclude_ids=post_ids | s4l_ids,
                             capture_parents=True)
             if on_replies else []
         )
 
-        # 4. Rank both surfaces by real engagement, then expand the top posts'
+        # 5. Rank both surfaces by real engagement, then expand the top posts'
         #    permalinks to capture thread continuations (and untruncated text).
         top_posts = rank_top(posts, args.top)
         top_replies = rank_top(comments, args.top)
@@ -481,7 +541,8 @@ def main() -> int:
             "comments": comments,
             "top_posts": top_posts,
             "top_replies": top_replies,
-            "counts": {"posts": len(posts), "comments": len(comments)},
+            "counts": {"posts": len(posts), "comments": len(comments),
+                       "s4l_posted_excluded": len(s4l_ids)},
             "grounding_instructions": GROUNDING_INSTRUCTIONS,
         }
 

package/scripts/snapshot.py

@@ -70,7 +70,7 @@ PERSONA_REQUIRED_FIELDS = ["name", "description", "voice", "search_topics"]
 CURRENT_WORKER_TASK_IDS = ("s4l-worker", "saps-worker")
 LEGACY_WORKER_TASK_IDS = ("saps-phase1-query", "saps-phase2b-draft")
 UPDATER_LABEL = "com.m13v.social-autoposter-update"
-AUTOPILOT_STALL_MS = 180_000
+AUTOPILOT_STALL_MS = 1_200_000
 
 # Milestones overlaid with LIVE state for display (the rest keep their ledger
 # value). Mirrors the overlay in buildSnapshot().

package/scripts/top_performers.py

@@ -567,9 +567,43 @@ def main():
                               "summary, no bottom posts). This is the lean "
                               "on-demand shape the drafting session calls "
                               "after routing a candidate to a project."))
+    parser.add_argument("--invoked-by", default=None,
+                        help=("Caller tag recorded in the on-demand invocation "
+                              "ledger (the drafting prompt passes the cycle's "
+                              "batch_id). Tracking only; no behavior change."))
     parser.add_argument("--json", action="store_true", help="Output as JSON")
     args = parser.parse_args()
 
+    # On-demand invocation ledger (2026-07-10). Any --project call is the
+    # on-demand per-project winners lookup the draft prompt offers; record it
+    # at the TOOL level (model self-reports are unreliable) so we can measure
+    # whether drafting sessions actually use the query. One JSON line per
+    # call in $S4L_STATE_DIR/top-performers-invocations.jsonl; the cycle
+    # counts lines for its batch_id after prep and logs a
+    # [project_top_performers] marker. Best-effort: never block the report.
+    if args.project:
+        try:
+            import datetime
+            state_dir = os.environ.get(
+                "S4L_STATE_DIR",
+                os.path.expanduser("~/.social-autoposter-mcp"))
+            os.makedirs(state_dir, exist_ok=True)
+            with open(os.path.join(state_dir,
+                                   "top-performers-invocations.jsonl"),
+                      "a") as fh:
+                fh.write(json.dumps({
+                    "ts": datetime.datetime.now(
+                        datetime.timezone.utc).isoformat(),
+                    "project": args.project,
+                    "platform": args.platform,
+                    "brief": bool(args.brief),
+                    "top": args.top,
+                    "invoked_by": args.invoked_by,
+                }) + "\n")
+        except Exception as exc:
+            print(f"[top_performers] invocation ledger write failed: {exc!r}",
+                  file=sys.stderr)
+
     (summary, style_perf, top, bottom, fallback_top,
      top_by_group, top_by_style) = _fetch_report_via_api(
         platform=args.platform, project=args.project, top=args.top, bottom=args.bottom,