@m13v/s4l 1.7.4-rc.1 → 1.7.4-rc.10

package/mcp/dist/index.js

@@ -5315,14 +5315,17 @@ async function main() {
     // the connected X profile and store the top-performing replies as
     // voice.examples + the persona_corpus.txt exemplar section. Additive only
     // (regenerates just its own marked corpus section; respects hand-written
-    // examples) and self-limiting (marker file rate-limits scan attempts;
-    // BAIL-ON-BUSY on the twitter-browser lock, so it never contends with a
-    // running cycle — it just retries on a later boot). Delayed so boot-time
-    // work (runtime provision, kicker install) settles first.
+    // examples) and self-limiting (no cooldown by design: success stamps
+    // examples_scanned_at which makes later boots a no-op, and until then it
+    // WAITS politely on the twitter-browser lock, polling while holding
+    // nothing, until cycles/DM runs free the browser, up to 12h before
+    // deferring to the next boot). Delayed so boot-time work (runtime
+    // provision, kicker install) settles first.
     const backfill = setTimeout(() => {
         if (isPaused())
             return;
-        void runPython("scripts/voice_exemplars.py", ["backfill"], { timeoutMs: 420_000 })
+        // timeout covers the 12h lock wait plus generous room for the scan itself
+        void runPython("scripts/voice_exemplars.py", ["backfill"], { timeoutMs: 13 * 3600_000 })
             .then((r) => {
             const last = r.stdout.trim().split("\n").slice(-1)[0] || "";
             console.error(`[social-autoposter-mcp] voice-exemplars backfill: ${last}`);

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.4-rc.1",
-  "installedAt": "2026-07-10T22:41:18.186Z"
+  "version": "1.7.4-rc.10",
+  "installedAt": "2026-07-11T01:28:53.237Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.4-rc.1",
+  "version": "1.7.4-rc.10",
   "description": "Draft, review, approve, and autopilot X/Twitter posts.",
   "long_description": "## **⚠️ The disclaimer above is generic Claude boilerplate.** Anthropic shows the same warning on every plugin regardless of what it does; any plugin has the same level of access as any app you download from the internet.\n\nS4L is an open source product developed by Mediar.ai Incorporated, a VC-backed San Francisco-based startup.\n\nTo get started:\n\n1\\. Copy this prompt: **Set me up on S4L plugin end to end**\n\n2\\. Quit with CMD+Q, reopen Claude, paste into a new chat.\n\nWhat happens next:\n\n* About every 5 minutes S4L scans X for posts that match your topics and drafts replies in your voice.\n* Drafts show up as review cards, usually the first within a few minutes. Nothing is posted automatically; you approve each one.\n* Posting autopilot stays off until you explicitly turn it on.",
   "author": {

package/mcp/menubar/s4l_card.py

@@ -732,6 +732,21 @@ class _ReviewController(NSObject):
         self._selected_draft = None
         self._draft_textviews = {}
         self._draft_scrolls = {}
+        # Per-draft hover dwell (two-draft cards, 2026-07-10): accumulated
+        # milliseconds the pointer spent over each draft box, so the feedback
+        # digest can tell an informed keep of Draft A (they read B and stayed)
+        # from a fast approve that says nothing about B. Raw ms ship on the
+        # decision; the read-vs-skim threshold lives digest-side so it can be
+        # tuned without a client release. _draft_hover_open holds the enter
+        # timestamp of any hover still in progress (flushed on decision).
+        self._draft_hover_ms = {0: 0, 1: 0}
+        self._draft_hover_open = {}
+        # Slots the caret has actually been in this card (2026-07-10 follow-up):
+        # lets the decision distinguish "clicked into B, then came BACK to A"
+        # (an explicit head-to-head choice of A, per user) from "never touched
+        # B at all". Only the UNCHOSEN slot's membership matters at decision
+        # time; the selected slot is trivially visited.
+        self._draft_visited = set()
         # Attention anchors for the unattended-review watchdog: the stack counts
         # as "touched" on present, on any tracked interaction, and on any
         # decision. No touch past the watchdog threshold = the user is not
@@ -1059,6 +1074,9 @@ class _ReviewController(NSObject):
             self._interactions = []
             self._card_shown_at = time.time()
             self._selected_draft = None
+            self._draft_hover_ms = {0: 0, 1: 0}
+            self._draft_hover_open = {}
+            self._draft_visited = set()
         self._reason_field = None
         content = NSView.alloc().initWithFrame_(NSMakeRect(0, 0, W, H))
 
@@ -1389,6 +1407,19 @@ class _ReviewController(NSObject):
                 tv.setDelegate_(self)
                 outline.addSubview_(scroll)
                 content.addSubview_(outline)
+                # Hover dwell per draft box (same NSTrackingArea pattern as the
+                # eye buttons): enter/exit timestamps accumulate into
+                # _draft_hover_ms[slot] so the decision can say whether the
+                # reviewer actually READ the draft they didn't pick. slot rides
+                # on userInfo, mirroring the eyes' `kind` routing.
+                outline.addTrackingArea_(
+                    NSTrackingArea.alloc().initWithRect_options_owner_userInfo_(
+                        outline.bounds(),
+                        NSTrackingMouseEnteredAndExited | NSTrackingActiveAlways,
+                        self,
+                        {"kind": "draft", "slot": slot},
+                    )
+                )
                 self._draft_scrolls[slot] = scroll
                 self._draft_outlines[slot] = outline
                 self._draft_textviews[slot] = tv
@@ -1542,21 +1573,32 @@ class _ReviewController(NSObject):
         self._show_details_popover()
 
     @objc.python_method
-    def _hover_kind(self, event):
-        """Which eye a tracking-area event belongs to ('stats' | 'details'),
-        from the userInfo stamped in _eye_button. Defaults to stats (the
-        original single-eye behavior) if the area carries no info."""
+    def _hover_info(self, event):
+        """(kind, slot) a tracking-area event belongs to, from the userInfo
+        stamped at creation: ('stats'|'details', None) for the eye icons,
+        ('draft', 0|1) for the two draft boxes. Defaults to ('stats', None),
+        the original single-eye behavior, if the area carries no info."""
         try:
             info = event.trackingArea().userInfo()
-            if info and info.get("kind") == "details":
-                return "details"
+            if info:
+                kind = info.get("kind")
+                if kind == "draft":
+                    return "draft", int(info.get("slot"))
+                if kind == "details":
+                    return "details", None
         except Exception:
             pass
-        return "stats"
+        return "stats", None
 
-    # NSTrackingArea owner callbacks (hover over either eye icon).
+    # NSTrackingArea owner callbacks (hover over either eye icon or, on
+    # two-draft cards, either draft box). Draft hovers only bank dwell time
+    # (no popover, no logging: the boxes are big and enter/exit fires on
+    # every pass of the pointer).
     def mouseEntered_(self, event):
-        kind = self._hover_kind(event)
+        kind, slot = self._hover_info(event)
+        if kind == "draft":
+            self._draft_hover_open[slot] = time.time()
+            return
         _log(f"{kind} eye hover enter")
         if kind == "details":
             self._show_details_popover()
@@ -1564,9 +1606,32 @@ class _ReviewController(NSObject):
             self._show_stats_popover()
 
     def mouseExited_(self, event):
+        kind, slot = self._hover_info(event)
+        if kind == "draft":
+            started = self._draft_hover_open.pop(slot, None)
+            if started is not None:
+                self._draft_hover_ms[slot] = self._draft_hover_ms.get(slot, 0) + int(
+                    (time.time() - started) * 1000
+                )
+            return
         _log("eye hover exit")
         self._close_stats_popover()
 
+    @objc.python_method
+    def _flush_draft_hovers(self):
+        """Bank any hover still in progress (pointer inside a draft box at
+        decision time, e.g. a keyboard approve) so _record reads final
+        totals."""
+        now = time.time()
+        for slot, started in list(self._draft_hover_open.items()):
+            self._draft_hover_ms[slot] = self._draft_hover_ms.get(slot, 0) + int(
+                (now - started) * 1000
+            )
+            # Keep the hover open (re-anchored at now) rather than deleting
+            # it: the pointer really is still inside the box, so a later
+            # mouseExited_ must not double-count the pre-flush span.
+            self._draft_hover_open[slot] = now
+
     @objc.python_method
     def _add_link(self, content, frame, text, url, *, size=12, bold=False, right=False, kind="link_click"):
         """Borderless button styled as a link (system link color, underlined).
@@ -1630,11 +1695,18 @@ class _ReviewController(NSObject):
         except Exception:
             return
         for slot, cand_tv in (self._draft_textviews or {}).items():
-            if cand_tv is tv and slot != self._selected_draft:
+            if cand_tv is not tv:
+                continue
+            # Visited even when it's already the selected slot: membership of
+            # the eventually-UNCHOSEN slot is what _record reads, and that
+            # slot only ever gets the caret via a deliberate user click (the
+            # auto-focus seat in _render targets the selected slot only).
+            self._draft_visited.add(slot)
+            if slot != self._selected_draft:
                 self._selected_draft = slot
                 self._textview = cand_tv
                 self._update_draft_borders()
-                break
+            break
 
     @objc.python_method
     def _update_draft_borders(self):
@@ -1704,9 +1776,32 @@ class _ReviewController(NSObject):
             chosen_draft = drafts[sel_idx]
             orig = (chosen_draft.get("text") or "").strip()
             draft_variant = chosen_draft.get("variant") or ("a" if sel_idx == 0 else "b")
+            # Full pairwise context for the feedback digest (2026-07-10): the
+            # UNCHOSEN draft's text+style ride along so "picked B over A" (or
+            # "kept A after reading B", per the hover dwell) is a usable
+            # preference PAIR, not just a winner with no loser. Shipped as one
+            # nested dict end to end (decision -> review event -> jsonb column)
+            # so adding a field never needs another schema hop.
+            self._flush_draft_hovers()
+            other = drafts[1 - sel_idx]
+            draft_choice = {
+                "variant": draft_variant,
+                "index": sel_idx,
+                "auto_selected": bool(sel_idx == 0),
+                "style": chosen_draft.get("style") or None,
+                "unchosen_text": (other.get("text") or "").strip() or None,
+                "unchosen_style": other.get("style") or None,
+                "hover_a_ms": int(self._draft_hover_ms.get(0, 0)),
+                "hover_b_ms": int(self._draft_hover_ms.get(1, 0)),
+                # True = the caret was in the unchosen box at some point, i.e.
+                # they tried the other draft and came back: an explicit choice
+                # even when the winner is the preselected default.
+                "visited_other": bool((1 - sel_idx) in self._draft_visited),
+            }
         else:
             orig = (d.get("reply_text") or "").strip()
             draft_variant = None
+            draft_choice = None
         link = d.get("link_url") or ""
         drop_link = False
         if approved:
@@ -1762,6 +1857,11 @@ class _ReviewController(NSObject):
                 "draft_variant": draft_variant,
                 "draft_index": sel_idx,
                 "draft_auto_selected": bool(dual and sel_idx == 0),
+                # Nested pairwise record (chosen vs unchosen text/style plus
+                # per-box hover dwell); None on single-draft candidates. The
+                # flat three fields above stay for their existing consumers
+                # (edit-learning variant stamp in s4l_menubar).
+                "draft_choice": draft_choice,
             }
         )
         self._last_decision_at = time.time()

package/mcp/menubar/s4l_menubar.py

@@ -2941,6 +2941,13 @@ class S4LMenuBar(rumps.App):
                     # posts); English translations on the card are display-only
                     # and never shipped here.
                     "language": decision.get("language"),
+                    # Two-draft pairwise context (None on single-draft cards):
+                    # {variant, index, auto_selected, style, unchosen_text,
+                    # unchosen_style, hover_a_ms, hover_b_ms}. Lets the
+                    # feedback digest learn "picked B over A" / "kept A after
+                    # actually reading B" as preference pairs. Older servers
+                    # simply ignore the key.
+                    "draft_choice": decision.get("draft_choice"),
                 }
             )
         except Exception:

package/mcp/menubar/s4l_state.py

@@ -786,6 +786,10 @@ def store_stamp_decision(batch, decision):
             "drop_link": bool(decision.get("drop_link")),
             "loved": bool(decision.get("loved")),
             "reject_category": decision.get("reject_category"),
+            # Two-draft pairwise record (chosen vs unchosen + hover dwell),
+            # None on single-draft cards. Durable locally so the choice
+            # survives even if the review-events flush never lands.
+            "draft_choice": decision.get("draft_choice"),
             "decided_at": time_iso(),
         }
         if decision.get("approved"):

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.4-rc.1",
+  "version": "1.7.4-rc.10",
   "private": true,
   "description": "Desktop MCP client for social-autoposter (X/Twitter rail): manual draft/review/approve loop, autopilot control, and stats. Thin wrapper over the existing pipeline scripts.",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l",
-  "version": "1.7.4-rc.1",
+  "version": "1.7.4-rc.10",
   "description": "Automated social posting pipeline for Reddit, X/Twitter, LinkedIn, and Moltbook. Install as a Claude Code agent skill.",
   "bin": {
     "social-autoposter": "bin/cli.js",

package/scripts/enrich_reply_parents.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+"""Fill parent-thread linkage on X replies discovered via the notifications lane.
+
+The X notifications feed does not expose the parent tweet id, so
+scan_twitter_mentions_browser.py inserts `replies` rows with mention_id only:
+no post_id, no parent_reply_id, and often no project_name. This script
+resolves the parent chain AFTER the fact, deterministically, with no browser
+and no model: fxtwitter's public JSON (already used by fetch_twitter_t1.py)
+returns `replying_to_status` for any tweet.
+
+Per row with (post_id IS NULL AND parent_reply_id IS NULL):
+  1. fxtwitter GET on their_comment_id -> parent tweet id + handle.
+  2. Walk up the ancestor chain (bounded hops) until the root.
+  3. First ancestor that is one of OUR posts (/api/v1/posts/lookup, wide
+     window) -> PATCH replies.post_id (+ project_name when the row has none).
+  4. Immediate parent that is another tracked reply
+     (/api/v1/replies?their_comment_id=) -> PATCH parent_reply_id + depth.
+  5. Root author -> PATCH thread_author_handle.
+
+Terminal misses (tweet deleted, protected, not-a-reply with nothing to link)
+are remembered in a local state file so recurring runs don't refetch forever.
+
+Usage:
+  python3 scripts/enrich_reply_parents.py --limit 20            # recurring lane
+  python3 scripts/enrich_reply_parents.py --backfill            # all missing rows
+  python3 scripts/enrich_reply_parents.py --ids 546832 542579   # specific rows
+  python3 scripts/enrich_reply_parents.py --limit 5 --dry-run
+
+All DB I/O goes through the s4l.ai HTTP API (http_api), never direct SQL.
+"""
+import argparse
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from http_api import api_get, api_patch  # noqa: E402
+
+STATE_PATH = os.environ.get(
+    "S4L_ENRICH_PARENTS_STATE",
+    os.path.expanduser("~/.social-autoposter-enrich-parents.json"),
+)
+MAX_HOPS = 6
+LOOKUP_DAYS = 3650
+
+
+def load_state():
+    try:
+        with open(STATE_PATH) as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def save_state(state):
+    tmp = STATE_PATH + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(state, f)
+    os.replace(tmp, STATE_PATH)
+
+
+def fetch_fxtwitter(handle, tweet_id):
+    """Returns (status, tweet_dict). status: 'ok' | 'gone' | 'transient'."""
+    url = f"https://api.fxtwitter.com/{handle or 'i'}/status/{tweet_id}"
+    req = urllib.request.Request(url, headers={"User-Agent": "social-autoposter/1.0"})
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            data = json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        # 401 = protected account, 404 = deleted. Both terminal.
+        if e.code in (401, 404):
+            return "gone", None
+        return "transient", None
+    except Exception:
+        return "transient", None
+    code = data.get("code")
+    if code == 200 and data.get("tweet"):
+        return "ok", data["tweet"]
+    if code in (401, 404):
+        return "gone", None
+    return "transient", None
+
+
+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).
+    """
+    chain = []
+    cur_handle, cur_id = handle, tweet_id
+    for _ in range(MAX_HOPS):
+        status, tweet = fetch_fxtwitter(cur_handle, cur_id)
+        time.sleep(sleep_s)
+        if status != "ok":
+            # 'gone' is terminal (deleted/protected); 'transient' must NOT be
+            # remembered, the next run retries it.
+            return chain, status
+        parent_id = tweet.get("replying_to_status")
+        parent_handle = tweet.get("replying_to") or ""
+        if not parent_id:
+            return chain, "root"
+        chain.append((str(parent_id), parent_handle))
+        cur_handle, cur_id = parent_handle, parent_id
+    return chain, "hop_cap"
+
+
+def lookup_our_post(tweet_id):
+    resp = api_get(
+        "/api/v1/posts/lookup",
+        query={"platform": "twitter", "post_id": str(tweet_id), "days": str(LOOKUP_DAYS)},
+    )
+    return (resp.get("data") or {}).get("post") or None
+
+
+def lookup_tracked_reply(tweet_id):
+    resp = api_get(
+        "/api/v1/replies",
+        query={"platform": "x", "their_comment_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 = []
+        for rid in ids:
+            resp = api_get(f"/api/v1/replies/{rid}")
+            row = (resp.get("data") or {}).get("reply")
+            if row:
+                out.append(row)
+        return out
+    query = {
+        "platform": "x",
+        "missing_parent": "1",
+        "order_by": "id",
+        "limit": str(limit),
+    }
+    if our_account:
+        query["our_account"] = our_account
+    if before_id:
+        query["before_id"] = str(before_id)
+    resp = api_get("/api/v1/replies", query=query)
+    return (resp.get("data") or {}).get("replies") or []
+
+
+def enrich_row(row, state, sleep_s, dry_run):
+    rid = row["id"]
+    tid = str(row.get("their_comment_id") or "")
+    handle = (row.get("their_author") or "").lstrip("@")
+    if not tid:
+        return "no_tweet_id"
+    if state.get(tid):
+        return "state_skip"
+
+    chain, terminal = walk_ancestors(handle, tid, sleep_s)
+    if not chain:
+        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]
+
+    patch = {}
+    matched_post = None
+    for anc_id, _anc_handle in chain:
+        post = lookup_our_post(anc_id)
+        if post:
+            matched_post = post
+            break
+    if matched_post:
+        patch["post_id"] = matched_post["id"]
+        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 terminal == "root":
+        root_handle = (chain[-1][1] or "").lstrip("@")
+        if 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"
+
+    if dry_run:
+        print(f"  [DRY] reply {rid}: {json.dumps(patch)}")
+        return "would_patch"
+
+    resp = api_patch(f"/api/v1/replies/{rid}", patch)
+    if resp.get("error"):
+        print(f"  ERROR patching reply {rid}: {resp['error']}", file=sys.stderr)
+        return "patch_error"
+    state[tid] = "linked"
+    kinds = "+".join(k for k in ("post_id", "parent_reply_id", "thread_author_handle") if k in patch)
+    print(f"  linked reply {rid}: {kinds} {json.dumps(patch)}")
+    return "linked"
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Backfill parent-thread linkage on X replies")
+    ap.add_argument("--limit", type=int, default=20, help="rows per run (recurring lane)")
+    ap.add_argument("--backfill", action="store_true", help="keep paging until no work is left")
+    ap.add_argument("--ids", nargs="*", type=int, help="enrich specific reply ids")
+    ap.add_argument("--our-account", default=None, help="scope to one posting handle")
+    ap.add_argument("--all-accounts", action="store_true", help="do not scope by handle")
+    ap.add_argument("--sleep", type=float, default=0.5, help="seconds between fxtwitter calls")
+    ap.add_argument("--dry-run", action="store_true")
+    args = ap.parse_args()
+
+    our_account = args.our_account
+    if not our_account and not args.all_accounts and not args.ids:
+        try:
+            from account_resolver import resolve as _resolve_account
+            our_account = _resolve_account("twitter")
+        except Exception:
+            our_account = None
+        if not our_account:
+            print("No twitter account resolvable; pass --our-account or --all-accounts", file=sys.stderr)
+            sys.exit(1)
+
+    state = load_state()
+    totals = {}
+    seen_ids = set()
+    before_id = None
+    while True:
+        rows = fetch_work(
+            args.limit if not args.backfill else 200, our_account, args.ids, before_id
+        )
+        rows = [r for r in rows if r["id"] not in seen_ids]
+        if not rows:
+            break
+        for row in rows:
+            seen_ids.add(row["id"])
+            # Terminal misses (deleted tweet, foreign thread) never leave the
+            # missing_parent queue; the id cursor pages past them.
+            before_id = row["id"] if before_id is None else min(before_id, row["id"])
+            outcome = enrich_row(row, state, args.sleep, args.dry_run)
+            totals[outcome] = totals.get(outcome, 0) + 1
+            if len(seen_ids) % 25 == 0 and not args.dry_run:
+                save_state(state)
+        if not args.dry_run:
+            save_state(state)
+        if args.ids or not args.backfill:
+            break
+
+    print(f"[enrich_reply_parents] processed={len(seen_ids)} " +
+          " ".join(f"{k}={v}" for k, v in sorted(totals.items())))
+
+
+if __name__ == "__main__":
+    main()

package/scripts/feedback_digest.py

@@ -82,6 +82,13 @@ MAX_EVENTS_PER_RUN = 200
 # degraded (a bad search topic, a draft-quality regression), not that any
 # single draft was wrong in a way the digest model could articulate.
 BULK_NO_REASON_THRESHOLD = int(os.environ.get("S4L_BULK_NO_REASON_THRESHOLD", "3"))
+# Two-draft cards ship raw per-box pointer-dwell ms in draft_choice; this is
+# the read-vs-skim floor for the draft the reviewer did NOT pick. At or above
+# it, keeping the preselected Draft A counts as an informed keep (they read B
+# and stayed); below it the approval says nothing about B. Threshold lives
+# HERE, not in the menubar client, so it can be tuned without a client
+# release.
+DRAFT_READ_MS = int(os.environ.get("S4L_DRAFT_READ_MS", "1000"))
 
 DISALLOWED_TOOLS = (
     "ScheduleWakeup,CronCreate,CronDelete,CronList,EnterPlanMode,EnterWorktree,"
@@ -106,10 +113,54 @@ def load_config():
         return {"projects": []}
 
 
+def _draft_choice(e: dict) -> dict | None:
+    """Parsed draft_choice payload (two-draft cards only). The API returns
+    jsonb as a dict; a locally-buffered event may still carry it as a JSON
+    string. None when absent, unparseable, or missing the unchosen draft
+    (nothing pairwise to say without the loser)."""
+    dc = e.get("draft_choice")
+    if isinstance(dc, str):
+        try:
+            dc = json.loads(dc)
+        except Exception:
+            return None
+    if not isinstance(dc, dict) or not (dc.get("unchosen_text") or "").strip():
+        return None
+    return dc
+
+
 def _event_line(e: dict) -> str:
     """One compact evidence line per event for the prompt."""
     parts = [f"[{e.get('decision')}{'+loved' if e.get('loved') else ''}]"]
     note = (e.get("reject_note") or "").strip()
+    # Two-draft pairwise flags (approvals only: on a reject BOTH drafts died,
+    # so which box the caret sat in carries no preference). Weighting ladder,
+    # explained to the model in build_prompt: an active switch to Draft B is
+    # strong (they necessarily read both); keeping the preselected A counts
+    # only when hover dwell shows they actually read B; a fast approve with B
+    # unread is flagged as exactly that so no preference gets fabricated.
+    dc = _draft_choice(e) if e.get("decision") == "approved" else None
+    show_unchosen = False
+    if dc:
+        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:
+                parts.append(
+                    f"kept_default_a_after_reading_b={round(other_ms / 1000, 1)}s"
+                )
+                show_unchosen = True
+            else:
+                parts.append("second_draft_not_read")
     if e.get("reject_category"):
         parts.append(f"category={e['reject_category']}")
     elif e.get("decision") == "rejected" and not note:
@@ -147,6 +198,13 @@ def _event_line(e: dict) -> str:
         line += f"\n  user REWROTE it to: {draft[:300]}"
     elif draft:
         line += f"\n  our draft was: {draft[:200]}"
+    if dc and show_unchosen:
+        line += f"\n  the draft they did NOT pick was: {(dc.get('unchosen_text') or '')[:300]}"
+        if dc.get("style") or dc.get("unchosen_style"):
+            line += (
+                f"\n  styles: picked={dc.get('style') or '?'}"
+                f" not_picked={dc.get('unchosen_style') or '?'}"
+            )
     url = (e.get("thread_url") or "").strip()
     if url:
         line += f"\n  thread: {url}"
@@ -205,6 +263,8 @@ 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. "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.
 
 Propose changes to the block. RULES, in priority order:
@@ -333,6 +393,16 @@ def _is_actionable(e: dict) -> bool:
     # as actionable as a reject (and it feeds edit_examples).
     if e.get("edited"):
         return True
+    # An explicit pairwise draft choice (switched to B, or tried B and came
+    # back to A) is style evidence on par with an edit; without this trigger a
+    # reviewer who mostly approves would bank pairwise signals behind the
+    # plain-approvals gate forever. Hover-only informed keeps stay
+    # NON-actionable on purpose: they are corroborating-weight evidence (like
+    # no_reason_given) and ride along with the next real trigger instead of
+    # burning a Claude turn on their own.
+    dc = _draft_choice(e)
+    if dc and (not dc.get("auto_selected") or dc.get("visited_other")):
+        return True
     return bool((e.get("reject_note") or "").strip())
 
 

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/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,

package/scripts/voice_exemplars.py

@@ -287,9 +287,8 @@ _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)."""
+    """One mkdir attempt on the pipelines' twitter-browser lock (same protocol
+    as skill/lock.sh, without its queue)."""
     try:
         _BROWSER_LOCK.mkdir()
     except OSError:
@@ -302,6 +301,34 @@ def _try_browser_lock() -> "Path | None":
     return _BROWSER_LOCK
 
 
+def _wait_browser_lock(max_wait_s: float, poll_s: float = 20.0) -> "Path | None":
+    """Wait for the twitter-browser lock however long it takes (up to
+    max_wait_s). Holds no other lock while waiting, so this cannot deadlock;
+    it just queues politely behind cycles / DM runs. Reclaims a stale lock
+    (holder pid dead + lease expired), mirroring skill/lock.sh."""
+    deadline = time.time() + max_wait_s
+    while True:
+        lock = _try_browser_lock()
+        if lock is not None:
+            return lock
+        try:
+            pid = int((_BROWSER_LOCK / "pid").read_text().strip())
+            expires = int((_BROWSER_LOCK / "expires_at").read_text().strip())
+            pid_alive = True
+            try:
+                os.kill(pid, 0)
+            except OSError:
+                pid_alive = False
+            if not pid_alive and time.time() > expires:
+                shutil.rmtree(_BROWSER_LOCK, ignore_errors=True)
+                continue  # retry mkdir immediately
+        except Exception:
+            pass  # lock mid-transition; just poll again
+        if time.time() >= deadline:
+            return None
+        time.sleep(poll_s)
+
+
 def _release_browser_lock() -> None:
     try:
         pid = (_BROWSER_LOCK / "pid").read_text().strip()
@@ -318,8 +345,12 @@ def cmd_backfill(args) -> int:
     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."""
+    dictation and hand-added material stay). No cooldown by design (user rule
+    2026-07-10): every boot retries until the scan succeeds; success stamps
+    examples_scanned_at, which makes all later boots a cheap no-op. Boots are
+    user-triggered (Desktop launch), so the worst case is one scan attempt per
+    launch, and concurrent waiters from overlapping boots dedupe via the
+    post-lock eligibility re-check."""
     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"}))
@@ -333,25 +364,30 @@ def cmd_backfill(args) -> int:
         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()
+        lock = _wait_browser_lock(args.max_wait_minutes * 60)
         if lock is None:
-            print(json.dumps({"ok": True, "did": "nothing", "reason": "browser_busy"}))
+            # Waited the whole window and never got the browser; the next
+            # boot simply tries again.
+            print(json.dumps({"ok": True, "did": "nothing", "reason": "browser_busy_timeout"}))
+            return 0
+        # The wait can be hours; another boot's backfill may have finished
+        # meanwhile. Re-read config and re-check before burning a scan.
+        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:
+            _release_browser_lock()
+            print(json.dumps({"ok": True, "did": "nothing", "reason": "done_while_waiting"}))
             return 0
         try:
             py = os.environ.get("S4L_PYTHON") or sys.executable or "python3"
+            # generous: the default depth (60 posts / 150 replies) can scroll
+            # for several minutes on prolific accounts
             r = subprocess.run([py, str(HERE / "scan_x_profile.py")],
-                               capture_output=True, text=True, timeout=300)
+                               capture_output=True, text=True, timeout=1200)
         except Exception as e:
             print(json.dumps({"ok": False, "did": "nothing", "reason": f"scan_failed: {e}"}))
             return 0
@@ -410,8 +446,9 @@ def main(argv) -> int:
     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("--max-wait-minutes", type=float, default=12 * 60,
+                   help="how long to wait for the twitter-browser lock before "
+                        "giving up until the next boot")
     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)

package/skill/engage-twitter.sh

@@ -68,6 +68,15 @@ python3 "$REPO_DIR/scripts/scan_twitter_mentions_browser.py" --json-file "$NOTIF
     || log "WARNING: Phase A scan_twitter_mentions_browser.py exited with code $?"
 rm -f "$NOTIFS_JSON"
 
+# Phase A2: fill parent-thread linkage on mention-discovered rows. The
+# notifications feed hides the parent tweet id, so scan rows land with
+# mention_id only; this resolves post_id / parent_reply_id / project via
+# fxtwitter HTTP (no browser, no model). Newest rows first, bounded per run.
+log "Phase A2: Enriching parent linkage on mention replies..."
+python3 "$REPO_DIR/scripts/enrich_reply_parents.py" --limit 25 2>&1 \
+    | tee -a "$LOG_FILE" \
+    || log "WARNING: Phase A2 enrich_reply_parents.py exited with code $?"
+
 # ═══════════════════════════════════════════════════════
 # PHASE B: Respond to pending Twitter replies
 # ═══════════════════════════════════════════════════════

package/skill/run-twitter-cycle.sh

@@ -2047,7 +2047,7 @@ 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
+   python3 $REPO_DIR/scripts/top_performers.py --platform twitter --project 'PROJECT_NAME' --top 3 --brief --invoked-by '$BATCH_ID'
 (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
@@ -2364,6 +2364,33 @@ if [ "$PREP_PARSE_EXIT" -eq 0 ] && [ -f "$PLAN_FILE" ]; then
 fi
 log "Phase 2b-prep complete. plan_count=$PLAN_COUNT"
 
+# On-demand project-winners usage marker (2026-07-10). top_performers.py
+# appends a JSON line to the state-dir ledger on every --project call (the
+# draft prompt tells the model to pass --invoked-by "$BATCH_ID"). Count this
+# batch's lines and log a greppable marker so "did the drafting session
+# actually use the per-project query" is answerable from the cycle log alone.
+# Stderr-marker convention: format is load-bearing elsewhere; keep it stable.
+TP_ONDEMAND=$(python3 -c "
+import json, os, sys
+path = os.path.join(os.environ.get('S4L_STATE_DIR', os.path.expanduser('~/.social-autoposter-mcp')), 'top-performers-invocations.jsonl')
+n, projects = 0, []
+try:
+    for line in open(path):
+        try:
+            r = json.loads(line)
+        except Exception:
+            continue
+        if r.get('invoked_by') == '$BATCH_ID':
+            n += 1
+            p = r.get('project')
+            if p and p not in projects:
+                projects.append(p)
+except OSError:
+    pass
+print(f'{n} projects={projects}')
+" 2>/dev/null || echo "0 projects=[]")
+log "[project_top_performers] batch=$BATCH_ID on_demand_invocations=$TP_ONDEMAND"
+
 # twitter-browser lock was already released right after thread-media capture
 # (before the Claude drafting call above), since nothing from there through
 # Phase 2b-gen touches the browser. Phase 2b-post re-acquires unconditionally