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

package/README.md

@@ -1,143 +1,176 @@
-# social-autoposter
+# S4L
 
-Open-source repo behind **[S4L (s4lai)](https://s4l.ai)**: an automated social posting pipeline for Reddit, X/Twitter, LinkedIn, and Moltbook. Ships as a Claude Code skill plus a set of standalone Python helpers and macOS launchd jobs.
+S4L is a desktop plugin for running a Reddit and X reply-drafting workflow from
+your own machine.
 
-> The hosted managed version is **S4L** (written `s4lai`, domain `s4l.ai`): done-for-you Reddit and Twitter brand-awareness, $1/1K impressions, $50/1K site visits. See https://s4l.ai.
+It watches the conversations your buyers already read, finds threads with real
+momentum and fit, drafts contribution-first replies in your voice, and gives you
+a review queue before anything goes live. The product is positioned as a
+self-serve desktop plugin: subscribe, install, connect your accounts, review the
+drafts, and track the results.
 
-State (posts, replies, candidates, stats) is read and written through the hosted S4L HTTP API (`AUTOPOSTER_API_BASE` + an install key in `~/social-autoposter/.env`); no database to provision. Each platform drives its own persistent Playwright MCP browser profile, so logins survive across runs.
+- Website: https://s4l.ai
+- Pricing: https://s4l.ai/pricing
+- Source: https://github.com/m13v/social-autoposter
 
-## Prerequisites
+## What S4L does
 
-A new machine needs all of these before the pipeline can run end to end:
+Most social tools start after you already know what to post. S4L starts earlier:
+it looks for conversations worth entering.
 
-- **macOS** (the launchd plists are mac-only; Linux users can crib the cron snippets from `setup/SKILL.md` Step 7)
-- **Node.js 16+** (for `npx`, the installer, and `@playwright/mcp` at runtime)
-- **Python 3.9+** with `pip3` (helper scripts; deps auto-installed by the installer)
-- **Claude Code CLI** on `PATH` (the cron scripts shell out to `claude -p` with a per-platform MCP config)
-- One Chromium install per platform (created on first run by `@playwright/mcp` against the persistent profile dirs)
+- Finds high-traffic Reddit and X threads with enough context to join well.
+- Ranks opportunities by momentum, intent, community norms, and product fit.
+- Drafts replies that answer the thread first and mention your product only when
+  it belongs.
+- Keeps project-specific voice, claim language, competitors, sensitive topics,
+  and hard lines in the drafting context.
+- Presents drafts in a review workflow so you can approve, reject, or edit before
+  posting.
+- Tracks views, upvotes, clicks, deletions, and misses so each run learns from
+  the previous one.
 
-Optional:
+Nothing is posted automatically by default. Posting autopilot stays off until you
+explicitly turn it on.
 
-- `MOLTBOOK_API_KEY` in `.env` for Moltbook posting and scanning
-- `RESEND_API_KEY` and `NOTIFICATION_EMAIL` in `.env` for DM-escalation emails
+## Who it is for
 
-## Install
+S4L is for founders and small teams who want an AI-assisted social workflow
+without handing their accounts to an agency or living inside mention alerts all
+day.
 
-```bash
-npx social-autoposter init
-```
+You bring the accounts, product context, voice, and judgment. The plugin handles
+thread discovery, draft generation, review cards, scheduling, and result memory.
 
-`bin/cli.js` does all of the wiring in one shot:
+## How users install it
 
-1. Copies `scripts/`, `skill/`, `setup/`, `SKILL.md`, and `browser-agent-configs/` into `~/social-autoposter/`
-2. Creates `config.json` from `config.example.json` and writes a blank `.env` template (fill in your S4L API key and optional `MOLTBOOK_API_KEY`)
-3. Installs the Python helper deps via `pip3` if missing
-4. Generates launchd plists in `~/social-autoposter/launchd/` with the user's actual `HOME` and `PATH`
-5. Installs the Playwright MCP configs to `~/.claude/browser-agent-configs/` (twitter, reddit, linkedin) with `__HOME__` and `__NODE_BIN__` placeholders substituted. Existing files are left alone, so any window-position tweaks survive `npx social-autoposter update`.
-6. Creates empty persistent browser profile dirs at `~/.claude/browser-profiles/{twitter,reddit,linkedin}`
-7. Symlinks `~/.claude/skills/social-autoposter` and `~/.claude/skills/social-autoposter-setup` to the install dir
+The production path is the desktop plugin download from S4L.
 
-To refresh code without touching user files (`config.json`, `.env`, `SKILL.md`, or any browser config you customized):
+1. Subscribe at https://s4l.ai/pricing.
+2. Download the plugin link emailed after checkout.
+3. Install the plugin in Claude Desktop.
+4. Start a new Claude chat and send:
 
-```bash
-npx social-autoposter update
+```text
+Set me up on S4L plugin end to end
 ```
 
-## Configure
+The setup flow repairs the local runtime, connects your X browser session,
+discovers product and voice context, seeds search topics, schedules draft
+generation, and verifies that draft cards appear without posting.
 
-Tell your Claude agent: **"set me up on social-autoposter plugin end to end"**. The
-setup skill treats that as a terminal goal:
+## What is in this repo
 
-1. Inspect and repair the owned runtime.
-2. Auto-detect the best browser profile and connect X/Twitter. macOS may require
-   a Safe Storage approval; a logged-out account may require one manual sign-in.
-3. Scan the X profile, discover and research the user's product, and infer a
-   conservative project, ICP, voice, and search topics without an interview.
-4. Save the project and seed its topics into the backend.
-5. Run a draft-only cycle to verify the pipeline without posting.
+This repository contains the open-source runtime behind the S4L plugin:
 
-The agent pauses only for an unavoidable login or when no product can be
-identified. Autopilot remains off until explicitly requested.
+```text
+social-autoposter/
+|-- mcp/                    Desktop plugin / MCP server, panel UI, release bundle
+|-- scripts/                Discovery, drafting, stats, telemetry, and queue helpers
+|-- skill/                  Shell entrypoints used by scheduled jobs
+|-- setup/                  End-to-end setup skill used by Claude
+|-- browser-agent-configs/  Browser automation profile templates
+|-- launchd/                macOS LaunchAgent templates
+|-- mcp-servers/            Local MCP helpers used by the runtime
+|-- config.example.json     Example project/account configuration
+`-- SKILL.md                Legacy social-autoposter agent playbook
+```
 
-## How the runtime is wired
+The `mcp/` package is the plugin users interact with. The rest of the repo is the
+pipeline it bundles, installs, and drives.
 
-```
-launchd  ──▶  skill/run-{platform}.sh  ──▶  claude -p  --strict-mcp-config  --mcp-config ~/.claude/browser-agent-configs/{platform}-agent-mcp.json
-                       │                                        │
-                       │                                        └──▶  @playwright/mcp@latest
-                       │                                                       │
-                       │                                                       └──▶  ~/.claude/browser-profiles/{platform}/  (persistent userDataDir)
-                       │
-                       ├──▶  scripts/find_threads.py, top_twitter_queries.py  (no browser, API dedup)
-                       ├──▶  scripts/pick_project.py            (weighted project rotation)
-                       ├──▶  scripts/top_performers.py          (feedback report from past stats)
-                       └──▶  S4L HTTP API                       (AUTOPOSTER_API_BASE in .env)
+## Architecture
+
+```text
+Claude Desktop plugin
+  -> S4L MCP server
+  -> local runtime + menu bar review UI
+  -> scheduled queue worker
+  -> browser profiles you control
+  -> S4L API for install-scoped queues, stats, and configuration
 ```
 
-Each `skill/run-*.sh`:
+Important properties:
 
-1. Controlled by launchd (load/unload). Use the dashboard Pause All / Resume All button, or `launchctl unload/load` directly
-2. Acquires a per-platform lock from `skill/lock.sh` (waits up to 60 min for any prior run)
-3. Sources `~/social-autoposter/.env`
-4. Picks a project, builds a feedback report, fetches `llms.txt` for product context
-5. Calls `find_*.py` for API-side candidates already deduped against the DB
-6. Spawns a child Claude process with `--strict-mcp-config` so it only sees the one platform's browser MCP
+- Runs locally on macOS.
+- Uses the user's own logged-in browser profiles.
+- Stores install state locally and scopes API calls by install identity.
+- Keeps secrets such as `.env`, `config.json`, browser profiles, logs, and local
+  databases out of Git.
+- Uses approval-first drafting as the default operating mode.
 
-The launchd schedules generated by `bin/cli.js` on install:
+## Develop from source
 
-| Job | Cadence |
-|-----|---------|
-| `com.m13v.social-stats` (`stats.sh`) | every 21600 s (6 h) |
-| `com.m13v.social-engage` (`engage.sh`) | every 21600 s (6 h) |
+For normal users, use the plugin download from S4L. These steps are for working
+on the repo itself.
 
-All per-platform plists live in `launchd/` (reddit-search, reddit-threads, twitter-cycle, linkedin, moltbook, github, octolens, audit, dm-replies-*, link-edit-*, scan-reddit-replies, scan-moltbook-replies, etc.) and use either `StartInterval` or `StartCalendarInterval` for fixed wall-clock times. Activate any of them with:
+Prerequisites:
+
+- macOS
+- Node.js 16+
+- Python 3.9+
+- Claude Desktop or Claude Code for MCP testing
+
+Install dependencies:
 
 ```bash
-ln -sf ~/social-autoposter/launchd/com.m13v.social-twitter-cycle.plist ~/Library/LaunchAgents/
-launchctl load ~/Library/LaunchAgents/com.m13v.social-twitter-cycle.plist
+npm install
+cd mcp
+npm install
 ```
 
-## Skill commands
-
-| Command | What it does |
-|---------|-------------|
-| `/social-autoposter` | Comment run: find threads, draft, post, log (cron-safe) |
-| `/social-autoposter post` | Create an original post or thread (manual only) |
-| `/social-autoposter stats` | Update engagement stats via API |
-| `/social-autoposter engage` | Scan and reply to responses on our posts |
-| `/social-autoposter audit` | Full browser audit of all posts |
+Build the plugin server and panel:
 
-View live stats at `https://s4l.ai/stats/<your-handle>` once posts start landing.
+```bash
+cd mcp
+npm run build
+```
 
-## Repo layout
+Register this checkout with Claude Desktop and Claude Code for local testing:
 
-```
-social-autoposter/
-├── SKILL.md                  the playbook (locked, immutable)
-├── bin/cli.js                installer + dashboard launcher
-├── browser-agent-configs/    Playwright MCP templates (twitter/reddit/linkedin)
-├── config.example.json       config template
-├── setup/SKILL.md            autonomous end-to-end setup skill (locked)
-├── scripts/                  Python and JS helpers (no browser, no LLM)
-├── skill/                    shell wrappers invoked by launchd
-└── launchd/                  generated macOS LaunchAgent plists
+```bash
+cd mcp
+node install.mjs
 ```
 
-## For other AI agents
+Then fully quit and reopen Claude so MCP servers reload.
 
-The skill works with any agent that has shell access, browser automation, and an LLM. The Python and JS helpers in `scripts/` handle thread discovery, reply scanning, and stats updates without needing a browser. `SKILL.md` is the playbook; any agent can read it and execute the workflows with its own tools.
+Run the test suite:
 
-## Pause and resume
+```bash
+npm test
+```
 
-Use the dashboard at `localhost:3141` (Pause All / Resume All button), or manually:
+Build a local `.mcpb` artifact without publishing:
 
 ```bash
-# Pause: unload all jobs + kill running processes
-for plist in ~/Library/LaunchAgents/com.m13v.social-*.plist; do launchctl unload "$plist"; done
-
-# Resume: reload all jobs
-for plist in ~/social-autoposter/launchd/com.m13v.social-*.plist; do
-  ln -sf "$plist" ~/Library/LaunchAgents/
-  launchctl load ~/Library/LaunchAgents/$(basename "$plist")
-done
+bash scripts/release-mcpb.sh --no-bump --no-npm --no-release
 ```
+
+That command packs the current pipeline into `mcp/dist/pipeline.tgz`, builds the
+plugin, creates `mcp/social-autoposter.mcpb`, and runs the release checks without
+touching npm or GitHub releases.
+
+## Runtime commands
+
+The plugin exposes MCP tools for the user-facing workflow:
+
+- `project_config` configures projects, products, voice, topics, and X auth.
+- `engagement_mode` chooses personal-brand and product-promotion lanes.
+- `dashboard` opens the review dashboard.
+- `post_drafts` posts only the drafts the user selected.
+- `get_stats` reads X/Twitter stats.
+- `pause_s4l` pauses or resumes scheduled S4L jobs.
+- `runtime` installs, updates, and diagnoses the local runtime.
+- `report_diagnosis` sends a support report to the S4L team.
+
+The legacy `/social-autoposter` skill and npm package remain in the repo because
+the plugin bundles and reuses the same pipeline scripts.
+
+## Public-repo hygiene
+
+This repo is public. Do not commit local customer data, browser state, generated
+media, private automation experiments, `.mcpb` bundles, `.env` files, databases,
+or logs. The root `.gitignore` intentionally keeps those out of source control.
+
+If a workflow needs private scratch space, keep it outside the repo or under an
+ignored directory.

package/mcp/dist/index.js

@@ -163,6 +163,9 @@ function plistXml(opts) {
     const schedule = opts.keepAlive
         ? `\t<key>KeepAlive</key>\n\t<true/>`
         : `\t<key>StartInterval</key>\n\t<integer>${opts.intervalSecs}</integer>`;
+    const abandon = opts.abandonProcessGroup
+        ? `\n\t<key>AbandonProcessGroup</key>\n\t<true/>`
+        : "";
     // Background (cron/autopilot) runs get the same Chrome the interactive cycle
     // uses, so a no-sudo ~/Applications install (which the shell's own resolver
     // doesn't scan) is still found off-screen. Omitted when Chrome resolves via
@@ -188,7 +191,7 @@ function plistXml(opts) {
 \t<array>
 ${args}
 \t</array>
-${schedule}
+${schedule}${abandon}
 \t<key>StandardOutPath</key>
 \t<string>${opts.stdoutLog}</string>
 \t<key>StandardErrorPath</key>
@@ -2987,7 +2990,7 @@ function queueDir() {
 // (which orphans the routines while their global SKILL.md files stay put, so the
 // SKILL.md-presence check in autopilotLoaded() reads a FALSE green). Mirrors the
 // menu bar's AUTOPILOT_STALL_SECONDS in mcp/menubar/s4l_menubar.py — keep in sync.
-const AUTOPILOT_STALL_MS = 180_000;
+const AUTOPILOT_STALL_MS = 1_200_000;
 // True when no scheduled-task routine is draining the draft queue. Two signals,
 // OR'd (keep in lockstep with mcp/menubar/s4l_menubar.py::_autopilot_stalled and
 // scripts/autopilot_stall_watch.py):
@@ -3500,6 +3503,9 @@ async function ensureQueueKickerInstalled() {
             stdoutLog: path.join(logDir, "launchd-twitter-cycle-stdout.log"),
             stderrLog: path.join(logDir, "launchd-twitter-cycle-stderr.log"),
             extraEnv: kickerEnv(),
+            // Don't let launchd reap the harness Chrome the cycle launches when the
+            // kicker shell exits (2026-07-12 foreground-steal loop).
+            abandonProcessGroup: true,
         });
         // Content-aware install: an existing box has the OLD kicker plist pointing at
         // run-twitter-cycle.sh (no merge step). ensurePlist won't overwrite, so detect
@@ -5315,7 +5321,8 @@ 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; it
+    // 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

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.4-rc.2",
-  "installedAt": "2026-07-10T23:25:56.505Z"
+  "version": "1.7.4-rc.22",
+  "installedAt": "2026-07-12T19:48:21.172Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.4-rc.2",
+  "version": "1.7.4-rc.22",
   "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

@@ -431,7 +431,21 @@ def _details_lines(d):
     d = d or {}
     lines = []
     style = (d.get("engagement_style") or "").strip()
-    if style:
+    # Two-draft cards (2026-07-11): name each slot's style so the reviewer
+    # can tell WHICH style produced the draft they are picking (Draft B is
+    # the exploration slot; its source arm renders separately below via the
+    # generic experiments lines). Single-draft cards keep the old one-liner.
+    _dual = d.get("drafts")
+    if isinstance(_dual, list) and len(_dual) == 2:
+        _slot_labels = {"a": "Draft A", "b": "Draft B"}
+        for _draft in _dual:
+            _s = (_draft.get("style") or "").strip()
+            if _s:
+                _label = _slot_labels.get(
+                    (_draft.get("variant") or "").strip().lower(), "Draft"
+                )
+                lines.append(f"{_label} style: {_s}")
+    elif style:
         lines.append(f"Style: {style}")
     desc = (d.get("style_description") or "").strip()
     if desc:
@@ -732,6 +746,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 +1088,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 +1421,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 +1587,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 +1620,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 +1709,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 +1790,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 +1871,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

@@ -403,13 +403,13 @@ DIAGNOSE_PROMPT_TEMPLATE = (
 # were firing. False-positive-free: an idle queue has no pending job at all, so a
 # quiet pipeline (no candidates) never trips this. Comfortably above the host
 # scheduler's per-minute cadence + a slow claim.
-AUTOPILOT_STALL_SECONDS = 180
+AUTOPILOT_STALL_SECONDS = 1200
 
 # A job CLAIMED but never finished (sits in running/ this long) means a worker
 # picked it up and then wedged mid-run (the claude -p drafting child died / never
 # spawned). Generous enough that the longest real drafting turn never trips it.
 # Keep in sync with RUNNING_STALL_SECONDS (scripts/autopilot_stall_watch.py).
-AUTOPILOT_RUNNING_STALL_SECONDS = 900
+AUTOPILOT_RUNNING_STALL_SECONDS = 1200
 
 # The "firing" window (how fresh lastRunAt must be) lives in the single source of
 # truth, scripts/schedule_state.py (FIRING_WINDOW there). _schedule_state delegates
@@ -898,7 +898,7 @@ class S4LMenuBar(rumps.App):
               to see between cycles) -> the ⚠ stays on continuously instead of
               flickering off. This is the durable signal.
           (2) FAST: a draft job has sat unclaimed in pending/ past
-              AUTOPILOT_STALL_SECONDS -> catches a fresh stall ~3 min in, before
+              AUTOPILOT_STALL_SECONDS -> catches a fresh stall ~20 min in, before
               the first full producer timeout has even latched (1).
           (3) IN-FLIGHT: a draft job was claimed (moved to running/) but never
               finished within AUTOPILOT_RUNNING_STALL_SECONDS -> the worker picked
@@ -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.2",
+  "version": "1.7.4-rc.22",
   "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.2",
+  "version": "1.7.4-rc.22",
   "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",